Heap Of Size Research Articles

Elementary Yet Precise Worst-Case Analysis of Floyd's Heap-Construction Program

The worst-case behavior of the heap-construction phase of Heapsort escaped mathematically precise characterization by a closed-form formula for almost five decades. This paper offers a proof that the exact number of comparisons of keys performed in the worst case during construction of a heap of size N is: 2N-2s2N-e2N, where s2N is the sum of all digits of the binary representation of N and e2N is the exponent of 2 in the prime factorization of N. It allows for derivation of this best-known upper bound on the number of comparisons of Heapsort: 2N-1$\lceil$lgN$\rceil$-2$\lceil$lgN$\rceil$+1-2s2N-e2N + 5.

Perfectly overlapped generation of long runs on a transputer array for sorting

Parallel algorithms are presented for generation of long sorted runs as the first phase of sorting a large file. They can generate runs of length about 2 mp on a one-way linear array of p processors each with a heap of size m. Internal computations can be completely overlapped with I/O, and most of the output time can be overlapped with the input time; thus, almost only input time is required. Experiments with the algorithms and their variations have been conducted using transputers. Although the data transfer between transputers is restricted to only a single direction, the experimental results show that all the versions can generate longer runs than a previous algorithm for a two-way transputer array. © 1997 Elsevier Science B.V.

An efficient algorithm for concurrent priority queue heaps

We present a new algorithm for concurrent access to array-based priority queue heaps. Deletions proceed top-down as they do in a previous algorithm due to Rao and Kumar [1988 (IEEE Trans. Computers 37(12))], but insertions proceed bottom-up, and consecutive insertions use a bit-reversal technique to scatter accesses across the fringe of the tree, to reduce contention. Because insertions do not have to traverse the entire height of the tree (as they do in previous work), as many as O(M) operations can proceed in parallel, rather than O(log M) on a heap of size M. Experimental results on a Silicon Graphics Challenge multiprocessor demonstrate good overall performance for the new algorithm on small heaps, and significant performance improvements over known alternatives on large heaps with mixed insertion/deletion workloads.

Perfectly Overlapped Generation of Long Runs for Sorting Large Files

A parallel algorithm is presented for quick generation of long sorted runs as the first phase of sorting a large file. It can generate runs of length about 2( m + 2) p on a linear array of p processors each with a heap of size m. Internal computations can be completely overlapped with I/O, and only n + ( m + 2) p steps are required to generate the runs from a file of n items. Experiments with the algorithm show that it can give highly satisfactory results in a real environment. A variant of the algorithm is also presented. It is possible that no merge phase is required for sorting a file occupying a whole disk.