Quicksort Algorithm—An Empirical Study

The Sorting Algorithm proposed by C.A.R Hoare  in 1961 by name Quick sort,  which is popularly known for being the fastest sorting algorithm. Quick sort  is still being practiced in the field of computers systems and its applications. The Algorithm whose efficiency to sort random data set is represented in asymptotic notation as  O(n log2 n) and when quick sort algorithm has a input data set which is already Ordered then it takes  a quadratic execution time which is considered as a worst case performance and this behavior is represented in asymptotic notation as O(n2). The  worst case performance is due the scan over heads which occur over the pre-sorted data set, in other words the partitioning gets skewed due to recursive calls and hence results in a quadratic complexity. This research paper presents an algorithm  which minimizes a worst case execution time making it linear when the input list is in non-decreasing order. The paper describes how the improvements are accommodated in the existing quick sort. A priori analysis of  proposed algorithm for different cases is made along with a proof of  correctness. Later the algorithm is verified for its correctness and asymptotic performance. The algorithm is implemented using C++ and also we have compared with other popular quick-sort version.

Research on sorting algorithms is a very core research field in computer science. Today, any advancement in sorting algorithms would lead to less time and space required to perform the sorting task. This paper discusses a newly proposed algorithm—‘ledger-based sorting algorithm’. It is basically an advancement to ‘counting sort’, but not exactly counting sort. The purpose of this paper is to reduce the time and space required for sorting when the numbers given to you belong to a particular range (0–n) and all of them are distinct. This paper also compares the newly proposed algorithm with insertion sort, bubble sort, selection sort, quick sort, merge sort and mainly counting sort through graphical time analysis of these algorithms. The paper especially compares counting sort algorithm with the proposed algorithm in terms of both time and space complexity.

Recent work by Google DeepMind introduced assembly-optimized sorting networks that achieve faster performance for small fixed-size arrays (3-8). In this research, we investigate the integration of these networks as base cases in classical divide-and-conquer sorting algorithms, specifically Merge Sort and Quick Sort, to leverage these efficient sorting networks for small subarrays generated during the recursive process. We conducted benchmarks with 11 different optimization configurations and compared them to classical Merge Sort and Quick Sort. We tested the configurations with random, sorted and nearly sorted arrays.

Quicksort is an important algorithm that uses the divide and conquer concept, and it can be run to solve any problem. The performance of the algorithm can be improved by implementing this algorithm in parallel. In this paper, the parallel sorting algorithm named the Multi-Deque Partition Dual-Deque Merge Sorting algorithm (MPDMSort) is proposed and run on a shared memory system. This algorithm contains the Multi-Deque Partitioning phase, which is a block-based parallel partitioning algorithm, and the Dual-Deque Merging phase, which is a merging algorithm without compare-and-swap operations and sorts the small data with the sorting function of the standard template library. The OpenMP library, which is an application programming interface used to develop the parallel implementation of this algorithm, is implemented in MPDMSort. Two computers (one with an Intel Xeon Gold 6142 CPU and the other with an Intel Core i7-11700 CPU) running Ubuntu Linux are used in this experiment. The results show that MPDMSort is faster than parallel balanced quicksort and multiway merge sort on the large random distribution data. A speedup of 13.81times and speedup per thread of 0.86 can be obtained. Thus, developers can use these parallel partitioning and merging algorithms to improve the performance of related algorithms.

В данной статье проводится анализ производительности различных алгоритмов сортировки в языке программирования JavaScript. Рассмотрены популярные алгоритмы, такие как сортировка вставками, выбором, слиянием, быстрая сортировка и сортировка счетчиком. Каждый алгоритм проанализирован с точки зрения времени выполнения и эффективности для различных размеров и типов данных.

We have a lot of sorting algorithms in practice in this modern informatica world. Most of them are operating in quadratic time, some have managed to get them down to logarithmic time combined with linear, but there is no sorting algorithm that is efficient enough to sort data in linear time alone. In this paper, we will try to devise some mathematical support to the failure of minimalizing the sorting algorithms in linear time by comparing three well-known approximations of ! with detailed mathematical proofs associated with it. Further, this paper deals with detailed mathematical analysis to support the fact the minimum time complexity that can be attained by a sorting algorithm is of order O( ) without taking into account any extrapolated system advancement or computer architecture modification. There are various sorting algorithms like Merge sort, Heap sort, Interpolation sort, etc. which attains this minimum possible time complexity (worst case). But if we consider some biased cases then better time complexity can be obtained. If the elements of the array are in arithmetic progression, then interpolation search takes lesser time and there are many such biased cases where a particular algorithm gives better output but this paper deals with the general case i.e., no conditions are imposed on the elements of the array.

As generative Artificial Intelligence (AI) models become increasingly integrated into software development workflows, understanding their efficiency and code quality is critical. This study offers a comprehensive comparison of three leading AI models—ChatGPT GPT-4-turbo, Claude Sonnet, and DeepSeek-V3—for automated code generation, focusing specifically on sorting algorithms. The models are evaluated across multiple metrics including execution time, memory usage, peak memory consumption, logical and physical file sizes, and code readability. Python implementations of Insertion Sort, Merge Sort, Quick Sort, and Heap Sort are generated by each model and benchmarked in a consistent Linux Docker environment. Results reveal that ChatGPT leads in overall efficiency, with the fastest average execution time, the lowest peak memory usage, and the highest readability scores. DeepSeek demonstrated competitive performance, especially in producing readable code, while Claude showed higher memory consumption and lower readability. This analysis provides practical insight into the trade-offs between code quality and system performance in AI-generated programming, offering valuable guidance for researchers and developers alike.

Sorting is the most fundamental operation in database system. There are many classical sorting algorithms and among them the most commonly‐used sorting algorithm in modern database system is merge sort. Merge sort is an efficient, general‐purpose, comparison‐based sorting algorithm. As merge sort is based on a divide and conquer model, it has found wide use in parallel computing algorithms. In this study, the authors present an adaptive sorting algorithm based on merge sort which is called array sort. Array sort not only takes advantages of merge sort, but also simplify the merge step by using a tag array. The proposed implementation consists of three phases: tag array creation phase, tag array split phase and list merge phase. Instead of just evaluating array sort in a single thread environment, the authors also run their experiments on multi‐thread to test how array sort performs.

Sorting is the procedure of arranging the elements in ascending or descending order. Sorting algorithms are not only used in computer science but also in our day-to-day life to reduce complexity. For optimizing the use of other algorithms, efficient sorting is required. This paper makes a comparison between merge sort, quick sort, selection sort and insertion sort by their time complexities.

Sorting algorithms play a crucial role in computing, but most are designed with rigid structure that are only efficient under certain conditions. Although some sorting algorithms perform well in some circumstances, they do not perform well on some resistant platforms. This study introduces Wall-L Merge Sort, which combines quadratic sorting with a modifiable multi-layer merging approach. By setting a single parameter, L, which determines the number of merge layers, Wall-L Sort shows a transition in the time complexity from O(n2) to without any modification in the unique idea. This degree of freedom enables a broad variety of input sizes to be encompassed and expands to several constraint platforms. The results show that Wall-L Sort and K-way Merge Sort have the built-in ability to handle different situations where other algorithms fail without assistance functions. Wall-L Merge Sort is the only sorting algorithm that combines complexity tuning, cache efficiency, recursion depth control, parallelism, and broad adaptability into one framework. It may not be the best choice for every situation, but its flexibility makes it a good fit for many different platforms, from small embedded systems to big computing systems. The theoretical and empirical evidence in this paper substantiates these advantages.

Sorting and merging are two problems that commonly arise in Computer Science especially in data processing tasks. To solve these problems, several algorithms have been developed. Similarly, existing merge and sorting algorithms have been improved to provide more efficient and accurate results. In this paper, selection and merging algorithms were developed on an octa-core processing machine using System.nanoTime methods in Java in order to compare their running times. The results obtained show that Merge Sort performs far better than selection sort with careful implementations by taking advantage of multiple processing cores in the test machine and some concurrency utility in Java. It was concluded that implementing algorithms using a machine with multiple numbers of cores in their Central Processing Unit (CPU) will result in a significant improvement in the performance of both algorithms.

Classification is one of the most important methods in data mining. These methods are used to extract meaningful information from large database which can be effectively used for predicting unknown class. The classifier based on decision tree is called Mixed Mode Data Base Miner (MMDBM) which is tested with different sorting techniques (merge sort, quick sort, radix sort) to compare the processing time to SLIQ classifier. In this paper, we carried out a comparative study on MMDBM classifier incorporating various sorting procedure by using Blood Pressure (BP) database, and finally the proposed method MMDBM classifier is one of the best classifiers among SLIQ supervised learning method. This proposed method achieved less processing time and higher rate of accuracy. Keywords: Classification, Data Mining, Java Sorting

Non-volatile memory (NVM) has emerged as an alternative of the next-generation memory due to its non-volatility, byte addressability, high storage-density, and low-energy consumption. However, NVM also has some limitations, e.g. asymmetric read and write latency. Therefore, at present, it is not realistic to completely replace DRAM with NVM in computer systems. A more feasible scheme is to adopt the hybrid memory architecture composed of NVM and DRAM. Following the assumption of hybrid memory architecture, in this paper, we propose an NVM-friendly sorting algorithm called NVMSorting. Particularly, we introduce a new concept called Natural Run to improve the existing MONTRES algorithm. Further, we apply the proposed NVMSorting to database join algorithms to improve the performance of the existing sort-merge join. To verify the performance of our proposal, we implement six existing sorting algorithms as baselines, including the MONTRES algorithm, and conduct comparative experiments on real Intel Optane DC persistent memory. The results show that NVMSorting outperforms other sorting algorithms in terms of execution time and NVM writes. In addition, the results of the join experiment show that the NVMSorting algorithm achieves the highest performance among all schemes. Especially, in the partially ordered data, the execution time of NVMSorting is 2.9%, 2.7%, and 4.2% less than MONTRES, external sort, and quick sort, respectively. Also, the amount of NVM writes of the NVMSorting is 26.1%, 43.6%, 96.2% less than MONTRES, external sort, and quick sort, respectively.

Enhanced Merge Sort- A New Approach to the Merging Process

The execution speed of the FPGA processing elements are compared to the microprocessor processing elements in the SRC 6 reconfigurable computer using the following algorithms for sorting: quick sort, heap sort, radix sort, bitonic sort, and odd/even merge. The results show that, for sorting, FPGA technology may not be the best processor choice and that factors such as memory bandwidth, clock speed, algorithm computational density and an algorithm's ability to be pipelined all have an impact on FPGA performance.