Internal Sorting Algorithm Research Articles

Sort race

AbstractSorting is one of the oldest computing problems and is still very important in the age of big data. Numerous algorithms and implementation techniques have been proposed. In this study, we focus on comparison based, internal sorting algorithms. We created 12 types of data of various sizes for experiments and tested extensively various implementations in a single setting. Using some effective techniques, we found that quicksort is adaptive to nearly sorted inputs and is still the best overall sorting algorithm. We also identified techniques that are effective in timsort, which is one of the most popular and efficient sorting methods based on natural mergesort. In addition, we created a version of our own mergesort, which performs better than timsort on nearly sorted instances. Our implementations of quicksort and mergesort are different from other implementations reported in all textbooks or research articles, and are faster than any version of the C library qsort functions not only for randomly generated data, but also for various types of nearly sorted data. This work can aid the user to choose the best sorting algorithm for the hard sorting job at hand, and provides a platform for anyone to test their own sorting algorithm against the best in the field.

External Sorting Algorithm: State-of-the-Art and Future Directions

The advent of the era of big data provides new opportunities and more challenges to sorting algorithms. The traditional internal sorting algorithm cannot adapt to the explosive growth of data, and the memory cannot accommodate all the data for sorting, so the external sorting algorithm arises at the historic moment. Because of the different application scenarios, storage devices and improvement strategies, there are many kinds of external sorting algorithms. Traditional main memory architecture based on DRAM faces the problems of capacity, energy consumption and reliability. Emerging nonvolatile memory technologies are non-volatile, high-density, byte-addressable, low-power, so they can replace persistent storage, main memory or storage class memory. Though NVM devices provide new choices to the revolution of traditional memory and storage system, traditional external sorting algorithms cannot achieve its performance. This paper first sorts out the development of external sorting algorithm, and summarizes it into four kinds of external sorting algorithm based on HDD, embedded device, SSD and NVM. In addition, the classical external sorting algorithms based on different storage devices are listed, and our opinions are put forward. Finally, this paper proposes three problems that need to be solved urgently in the future development of external

Inversion-sensitive sorting algorithms in practice

We study the performance of the most practical inversion-sensitive internal sorting algorithms. Experimental results illustrate that adaptive AVL sort consumes the fewest number of comparisons unless the number of inversions is less than 1%; in such case Splaysort consumes the fewest number of comparisons. On the other hand, the running time of Quicksort is superior unless the number of inversions is less than 1.5%; in such case Splaysort has the shortest running time. Another interesting result is that although the number of cache misses for the cache-optimal Greedysort algorithm was the least, compared to other adaptive sorting algorithms under investigation, it was outperformed by Quicksort.

An Improved HEAPSORT Algorithm with nlogn − 0.788928n Comparisons in the Worst Case

A new variant of HEAPSORT is presented in this paper. The algorithm is not an internal sorting algorithm in the strong sense, since extra storage for n integers is necessary. The basic idea of the new algorithm is similar to the classical sorting algorithm HEAPSORT, but the algorithm rebuilds the heap in another way. The basic idea of the new algorithm is it uses only one comparison at each node. The new algorithm shift walks down a path in the heap until a leaf is reached. The request of placing the element in the root immediately to its destination is relaxed. The new algorithm requires about n log n − 0.788928n comparisons in the worst case and n log n − n comparisons on the average which is only about 0.4n more than necessary. It beats on average even the clever variants of QUICKSORT, if n is not very small. The difference between the worst case and the best case indicates that there is still room for improvement of the new algorithm by constructing heap more carefully.

An empirical study of the run-time behavior of quicksort, Shellsort and mergesort for medium to large size data

The paper describes the results of a large empirical study to measure the practical behavior of the basic versions of the popular internal sorting algorithms, Shellsort, quicksort, and mergesort, for medium to large size data and compares them with previous results. The results give running times of θ( N 1.25) for Shellsort, quicksort, and mergesort for 1000 < N < 2 × 10 6. The study also shows that Shellsort behaves better than mergesort for 1000 < N < 150,000. However, mergesort outperforms Shellsort for N > 150,000. Quicksort outperforms both Shellsort and mergesort for all values of N > 1000. Our fits show better performance for Shellsort than the previous studies and are mostly accurate to within 2% for 1000 < N < 2 × 10 6. The primary reason for this error seems to be related to the error in the measured data.

A parallel partition for enhanced parallel QuickSort

QuickSort is a favoured sequential internal sorting algorithm due to its fast average running time and its small memory requirements. Previous investigations into its parallel execution have failed to address the O( n) running time of the partition step with consequent performance limitations. This paper presents an effective parallel partitioning algorithm for the shared memory multiprocessor model. The parallel partition algorithm involves slicing the original data set into several independent subsets. Concurrent partitioning of the subsets is followed by a sequential combination process to finalize the partition. The cost of this sequential combination process is very much less than the cost of the original sequential partition, leading to enhanced algorithmic performance of parallel QuickSort. The technique used to successfully parallelize an operation which on the surface appears to be inherently sequential is also of interest.

Timing results of some internal sorting algorithms on the ETA 10-P

The timing results on the performance of some sorting algorithms on vector computers presented recently by Rönsch and Strauss, and by Carnevali are supplemented with data for the new ETA 10-P supercomputer. The DIAMONDSORT and RADIXSORT vector algorithms in their FORTRAN 200 implementation due to Krieger are tested and compared against the CYBER 205. The MAGEV library routine QSORT is also tested. For the RADIXSORT routine without keeping index list, the ETA 10-P outperforms all the machines but the CYBER 205 (for all previously tested algorithms) at vector lengths equal or longer than 25 600 elements.

Timing results of some internal sorting algorithms on the IBM 3090

The information contained in a paper by Rönsch adn Strauss on the performance of sorting algorithms on vector computers is completed with performance data of the IBM 3090 on sorting. For scalar sorting, the IBM 3090 turns out to be faster than all the machines considered by Rönnsch and Strauss. Due to this high scalar speed, FORTRAN-coded vector sorting is never more efficient than scalar sorting on the IBM 3090, at least for the vector sorting algorithms considered. On the other hand, for optimized library routines the IBM 3090 outperforms the CRAY X-MP (but not the AMDAHL 1200) at most vector lenghts.

Timing results of some internal sorting algorithms on vector computers

Seven internal methods for sorting a set ( a 1, a 2,…, a n ) of real numbers into non-descending order are compared with regard to their performance on the vector computers CRAY-1S, CRAY-1M, CRAY X-MP, AMDAHL 1100, AMDAHL 1200 and the AMDAHL 470/V7. The algorithms considered are: Bubble sort, odd-even transposition sort, Batcher's parallel merge-exchange sort, heapsort, quicksort, vector quicksort and diamond sort. Moreover, certain variants of some of these algorithms are also considered. The suitability of the algorithms with respect to vector machine implementation is discussed and the FORTRAN Cray codes for Batcher's parallel merge-exchange sort as well as Diamond sort are given.

An Adaptive Method for Unknown Distributions in Distributive Partitioned Sorting

Distributive Partitioned Sort (DPS) is a fast internal sorting algorithm which rung in O(n) expected time on uniformly distributed data. Unfortunately, the method is biased toward such inputs, and its performance worsens as the data become increasingly nonuniform, such as with highly skewed distributions. An adaptation of DPS, which estimates the cumulative distribution function of the input data from a randomly selected sample, was developed and tested. The method runs only 2-4 percent slower than DPS in the uniform case, but outperforms DPS by 12-13 percent on exponentially distributed data for sufficiently large files.

Virtual Memory Behavior of Some Sorting Algorithms

Experimnental results are given about the performance of six sorting algorithms in a virtual memory based on the working set principle. With one exception, the algorithms are general internal sorting algorithms and not especially tuned for virtual memory. Algorithms are compared in terms of their time requirements, space requirements, and space-time integrals. The relative performances of the algorithms vary from one measure to the other. Especially in terms of a space-time integral, quicksort turns out to be the best algorithm, also in a working set virtual memory environment.