Results 1 
8 of
8
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.
No sorting? Better searching!
, 2005
"... Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. The sorted organization is amenable for searching a set of n keys, since each search requires Θ(log n) comparisons in the worst case, which is optimal if the cost of a single comparison can be considered a constant. Nevertheless, we prove that disorder implicitly provides more information than order does. For the general case of searching an array of multidimensional keys, whose comparison cost is proportional to their length (and hence cannot be considered a constant), we demonstrate that “suitable” disorder gives better bounds than those derivable by using the natural lexicographic order. We start out from previous work done by Andersson, Hagerup, H˚astad and Petersson [SIAM Journal on Computing, 30(2), 2001], who proved that k log log n
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
(Show Context)
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
(Show Context)
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.
Ph.D. thesis
"... Data structures for orthogonal intersection searching and other problems ..."
(Show Context)
Optimal InPlace Sorting of Vectors and Records
"... Abstract. We study the problem of determining the complexity of optimal comparisonbased inplace sorting when the key length, k, is not a constant. We present the first algorithm for lexicographically sorting n keys in O(nk+n log n) time using O(1) auxiliary data locations, which is simultaneously ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We study the problem of determining the complexity of optimal comparisonbased inplace sorting when the key length, k, is not a constant. We present the first algorithm for lexicographically sorting n keys in O(nk+n log n) time using O(1) auxiliary data locations, which is simultaneously optimal in time and space. 1
Abstract
, 2005
"... Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. ..."
Abstract
 Add to MetaCart
Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. The sorted organization is amenable for searching a set of n keys, since each search requires Θ(log n) comparisons in the worst case, which is optimal if the cost of a single comparison can be considered a constant. Nevertheless, we prove that disorder implicitly provides more information than order does. For the general case of searching an array of multidimensional keys, whose comparison cost is proportional to their length (and hence cannot be considered a constant), we demonstrate that “suitable ” disorder gives better bounds than those derivable by using the natural lexicographic order. We start out from previous work done by Andersson, Hagerup, H˚astad and Petersson [SIAM Journal on Computing, 30(2), 2001], who proved that k log log n
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
(Show Context)
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.