Improving Merge Sort and Quick Sort Performance by Utilizing Alphadev’s Sorting Networks as Base Cases

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.

Quick sort is one of the most sought after algorithms, because if implemented properly quick sort could be much faster than its counterparts, merge sort and heapsort. The main crux of quick sort algorithm is the implementation of the partitioning operation. Nico Lomuto and C. A. R Hoare have put forth partitioning algorithms that have gained prominent significance. Despite this, one can always shed more light on this partially understood operation of partition. Sorting algorithms have been further developed to enhance its performance in terms of computational complexity, memory and other factors. The proposed method is the use of randomized pivot in the implementation of Lomuto partition and Hoare partition algorithms, respectively. It is analysed with and without a randomized pivot element. This paper presents a comparison of the performance of a quick sort algorithm in different cases using contrasting partition approaches with and without randomized pivot. The results provide a theoretical explanation for the observed behaviour and give new insights on behaviour of quick sort algorithm for different cases. The Hoare partition approach with randomized pivot gives best time complexity in comparison to the other cases.

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

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.

In this paper, we show how the theory of sorting networks can be applied to synthesize optimized general-purpose sorting libraries. Standard sorting libraries are often based on combinations of the classic Quicksort algorithm, with insertion sort applied as base case for small, fixed, numbers of inputs. Unrolling the code for the base case by ignoring loop conditions eliminates branching, resulting in code equivalent to a sorting network. By replacing it with faster sorting networks, we can improve the performance of these algorithms. We show that by considering the number of comparisons and swaps alone we are not able to predict any real advantage of this approach. However, significant speed-ups are obtained when taking advantage of instruction level parallelism and non-branching conditional assignment instructions, both of which are common in modern CPU architectures. Furthermore, a close control of how often registers have to be spilled to memory gives us a complete explanation of the performance of different sorting networks, allowing us to choose an optimal one for each particular architecture. Our experimental results show that using code synthesized from these efficient sorting networks as the base case for Quicksort libraries results in significant real-world speed-ups.

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.

Merging and sorting algorithms are the backbone of many modern computer applications. As such, efficient implementations are desired. Recent architectural advancements in CPUs (Central Processing Units), such as wider and more powerful vector instructions, allow for algorithmic improvements. This paper presents a new approach to merge sort using vector instructions. Traditional approaches to vectorized sorting typically utilize a bitonic sorting network (Batcher's Algorithm) which adds significant overhead. Our approach eliminates the overhead from this approach. We start with a branch-avoiding merge algorithm and then use the Merge Path algorithm to split up merging between the different SIMD lanes. Testing demonstrates that the algorithm not only surpasses the SIMD based bitonic counterpart, but that it is over 2.94X faster than a traditional merge, merging over 300M keys per second in one thread and over 16B keys per second in parallel. Our new sort reaches is over 5X faster than quicksort and 2X faster than Intel's IPP library sort, sorting over 5.3M keys per second for a single processor and in parallel over 500M keys per second and a speedup of over 2x from a traditional merge sort.

Enhanced Merge Sort- A New Approach to the Merging Process

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.

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.

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.

Model Predictive Control is a promising technique for electric drive control, as it enables optimization for multiple parameters and offers reliable operation with non-linear systems. For induction machine drives it can be realized using separate cost functions for the torque and the stator flux. Although this eliminates the problem of calculating any weighting factor, the selection of the final voltage vector requires an additional sorting algorithm. By increasing the number of voltage levels or the prediction horizon, the sorting algorithm becomes more and more time-intensive, which can severely impair the performance of the control algorithm. This paper introduces a novel hybrid sorting algorithm consisting of two sorting networks and a merging step. As a case study, the described control method is applied for an induction machine with high rated frequency fed by a three-level inverter, while also discussing the implementation issues. Experimental results verify the operation of the devised sorting algorithm.

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.

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