Results 1 
4 of
4
The complexity of implicit and spaceefficient priority queues
 Proceedings of the 9th Workshop on Algorithms and Data Structures, Lecture
"... Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and logarithmic time for deletemin. Our second result is a lower bound showing that that one extra word really is necessary. We reduce the decreasekey operation to a cellprobe type game called the Usher's Problem, where one must maintain a simple data structure without the aid of any auxiliary storage.
An Efficient Multi Join Algorithm Utilizing a Lattice of Double Indices
"... Abstract—In this paper, a novel multi join algorithm to join multiple relations will be introduced. The novel algorithm is based on a hashedbased join algorithm of two relations to produce a double index. This is done by scanning the two relations once. But instead of moving the records into bucket ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract—In this paper, a novel multi join algorithm to join multiple relations will be introduced. The novel algorithm is based on a hashedbased join algorithm of two relations to produce a double index. This is done by scanning the two relations once. But instead of moving the records into buckets, a double index will be built. This will eliminate the collision that can happen from a complete hash algorithm. The double index will be divided into join buckets of similar categories from the two relations. The algorithm then joins buckets with similar keys to produce joined buckets. This will lead at the end to a complete join index of the two relations. without actually joining the actual relations. The time complexity required to build the join index of two categories is Om log m where m is the size of each category. Totaling time complexity to O n log m for all buckets. The join index will be used to materialize the joined relation if required. Otherwise, it will be used along with other join indices of other relations to build a lattice to be used in multijoin operations with minimal I/O requirements. The lattice of the join indices can be fitted into the main memory to reduce time complexity of the multi join algorithm.
A Novel InPlace Sorting Algorithm with O(n log z) Comparisons and O(n log z) Moves
, 2006
"... Abstract—Inplace sorting algorithms play an important role in many fields such as very large database systems, data warehouses, data mining, etc. Such algorithms maximize the size of data that can be processed in main memory without input/output operations. In this paper, a novel inplace sorting a ..."
Abstract
 Add to MetaCart
Abstract—Inplace sorting algorithms play an important role in many fields such as very large database systems, data warehouses, data mining, etc. Such algorithms maximize the size of data that can be processed in main memory without input/output operations. In this paper, a novel inplace sorting algorithm is presented. The algorithm comprises two phases; rearranging the input unsorted array in place, resulting segments that are ordered relative to each other but whose elements are yet to be sorted. The first phase requires linear time, while, in the second phase, elements of each segment are sorted inplace in the order of z log (z), where z is the size of the segment, and O(1) auxiliary storage. The algorithm performs, in the worst case, for an array of size n, an O(n log z) element comparisons and O(n log z) element moves. Further, no auxiliary arithmetic operations with indices are required. Besides these theoretical achievements of this algorithm, it is of practical interest, because of its simplicity. Experimental results also show that it outperforms other inplace sorting algorithms. Finally, the analysis of time and space complexity, and required number of moves are presented, along with the auxiliary storage requirements of the proposed algorithm. Keywords—Auxiliary storage sorting, inplace sorting, sorting. I.
A Multi Join Algorithm Utilizing Double Indices
"... Join has always been one of the most expensive queries to carry out in terms of the amount of time to process. This paper introduces a novel multi join algorithm to join multiple relations. The novel algorithm is based on a hashedbased join of two relations to produce a double index. This is done b ..."
Abstract
 Add to MetaCart
Join has always been one of the most expensive queries to carry out in terms of the amount of time to process. This paper introduces a novel multi join algorithm to join multiple relations. The novel algorithm is based on a hashedbased join of two relations to produce a double index. This is done by scanning the two relations once. Instead of moving the records into buckets, a double index is built. This will eliminate collision as a result of a complete hash algorithm. The double index will be divided into join buckets of similar categories from the two relations. Buckets with similar keys are joined to produce joined buckets. This will lead at the end to a complete join index of the two relations without actually joining the actual relations. The time complexity required to build the join index of two categories is O(m log m) where m is the size of each category. The proposed algorithm has a time complexity of O (n log m) for all buckets where n is the number of buckets. The join index will be used to materialize the joined relation if required. Otherwise, along with other join indices of other relations, the join index builds a lattice to be used in multijoin operations with minimal I/O requirements. The lattice of the join indices can be fitted into the main memory to reduce time complexity of the multi join algorithm. 1.