Ledger-Based Sorting Algorithm

An alternative taxonomy (to that of Knuth and others) of sorting algorithms is proposed. It emerges naturally out of a top-down approach to the derivation of sorting algorithms. Work done in automatic program synthesis has produced interesting results about sorting algorithms that suggest this approach. In particular, all sorts are divided into two categories: hardsplit/easyjoin and easysplit/hardjoin. Quicksort and merge sort, respectively, are the canonical examples in these categories. Insertion sort and selection sort are seen to be instances of merge sort and quicksort, respectively, and sinking sort and bubble sort are in-place versions of insertion sort and selection sort. Such an organization introduces new insights into the connections and symmetries among sorting algorithms, and is based on a higher level, more abstract, and conceptually simple basis. It is proposed as an alternative way of understanding, describing, and teaching sorting algorithms.

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 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.

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

Assalamu’alaikum Wr. Wb. and Greetings.I am pleased and honored to welcome you at the First International Conference on Computer Science and Applied Mathematic (ICCSAM 2018), which was held this year by AMIK and STIKOM Tunas Bangsa Pematangsiantar in collaboration with the Indonesian Computer and Information Professional Association (IPKIN), Indonesian Mathematical Society (INDOMS) and Bank Muamalat. As Chair of the Foundation, I would like to convey a greeting Welcome to Parapat City Lake Toba to presenters from various countries and especially those I respect for the presence of scientists in the field of Computer and Mathematical Sciences and industry practitioners in the 2018 ICCSAM event.I see that this activity is designed to enhance the exchange of knowledge and new discoveries in computer science and mathematics and related fields in industry. I hope that scientists in the field of computer science and mathematics and those who work in the industry can share knowledge and work together as a team that has mutual relations with each other. I am very pleased to say that the theme of this conference, “Advancing Computability Innovation” is very much in line with the objectives of AMIK and STIKOM conferences and missions, namely “to become a Science and Technology based Study Program that meets industrial needs and functions as a research center in Information Data Science. The conference was held in response to output and aoutcame which had a significant contribution in the field of computer science and mathematics as an inseparable unit of science towards the development of local and global industries. It is our happiness and honor to welcome distinguished professors present to convey their expertise at this conference.I hope this meeting will enable the development of productive dialogue between participants from various countries. They also provide invaluable opportunities for networking among participants, institutions and industries. I also hope that diversity in these fields can reveal more opportunities for researchers and practitioners from all over the world to start a lot of research related to the industry in the future.I would like to congratulate AMIK and STIKOM Tunas Bangsa for starting this conference with a synergistic contribution from dedicated partners namely the USU Faculty of Mathematics and Natural Sciences, USU’s Faculty of Computer and Information Technology, the Indonesian Computer and Informatics Professional Association (IPKIN), Indonesian Mathematical Society (INDOMS), Bank Muamalat, Malaysia Pahang University (UMP), University of Essex, United Kingdom, Ankara, Turkey and Institute of Applied Mathematics Middle East Technical University to all delegates for their full support, cooperation and contribution to the 2018 ICCSAM. I also want to thank the Organizing Committee for their perseverance and extraordinary efforts. Various sponsors are also rewarded for their contributions. I really hope that all participants will get a pleasant stay here at NIAGARA HOTEL and bring back unforgettable experiences and valuable knowledge from this conference.Thanks.H. Ahmad Ridwansyah Putra

The aim of this paper is to compare the complexity of three simple sort algorithm; selection sort algorithm, bubble sort algorithm, and insertion sort algorithm. The measurement of the complexity is based on control flow structure and time processing. The control flow structure is illustrated into flowgraph and measured by number of out-degree and number of in-degree. The algorithm is coded in C programming language. The sorting experiment uses four data sets: 100,000 random words, 50,000 random words, 100,000 random integer numbers, and 50,000 random integer numbers to measure the time processing. The result of the measurement explains that the bubble sort algorithm has the complexity more than others.

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.

Counting sort is a simple, stable and efficient sort algorithm with linear running time, which is a fundamental building block for many applications. This paper depicts the design issues of a data parallel implementation of the count sort algorithm on a commodity multiprocessor GPU using the Compute Unified Device Architecture (CUDA) platform, both from NVIDIA Corporation. The full parallel version runs much faster than any serial implementation on CPU with the loss of stability due to the limitation of the massive threads parallel model. But the thread-level parallel implementation still provides an efficient parallel sort primitive for many applications, which do not require stable sort or can be adapted for unstable subroutines.

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.

One of the basic problem in computer science is to arrange the items in lexicographic order. Sorting is one of the major research topic. There are number of sorting algorithms. This paper presents the implementation and detailed analysis of library sort. Library sort is also called gapped insertion sort. It is a sorting algorithm that uses insertion sort with gaps. Time taken by insertion sort is O (n <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> ) because each insertion takes O (n) time; and library sort has insertion time O (log n) with high probability. Total running time of library sort is O (n log n) time with high probability. Library sort has better run time than insertion sort, but the library sort also has some issues. The first issue is the value of gap which is denoted by `ε', the range of gap is given, but it is yet to be implemented to check that given range is satisfying the concept of library sort algorithm. The second issue is re-balancing which accounts the cost and time of library sort algorithm. The third issue is that, only a theoretical concept of library sort is given, but the concept is not implemented. So, to overcome these issues of library sort, in this paper, we have implemented the concept of library sort and done the detailed experimental analysis of library sort algorithm, and measure the performance of library sort algorithm on a dataset.

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.

The Sorting Algorithm proposed by C.A.R Hoare&nbsp; in 1961 by name Quick sort,&nbsp; which is popularly known for being the fastest sorting algorithm. Quick sort&nbsp; 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&nbsp; O(n log2 n) and when quick sort algorithm has a input data set which is already Ordered then it takes&nbsp; a quadratic execution time which is considered as a worst case performance and this behavior is represented in asymptotic notation as O(n2). The&nbsp; 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&nbsp; 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&nbsp; proposed algorithm for different cases is made along with a proof of&nbsp; 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.

The Shell sort algorithm is one of the most practically effective in-place sorting algorithms. However, it is difficult to execute this algorithm with its intended running time complexity on data encrypted using fully homomorphic encryption (FHE), because the insertion sort in Shell sort has to be performed by considering the worst-case input data. In this paper, in order for the sorting algorithm to be used on the FHE data, we modify the Shell sort with an additional parameter α, allowing exponentially small sorting failure probability. For a gap sequence of powers of two, the modified Shell sort with input array length n is found to have the trade-off between the running time complexity of O(n3/2√α+loglogn) and the sorting failure probability of 2-α. Its running time complexity is close to the intended running time complexity of O(n3/2) and the sorting failure probability can be made very low with slightly increased running time. Further, the near-optimal window length of the modified Shell sort is also derived via convex optimization. The proposed analysis of the modified Shell sort is numerically confirmed by using randomly generated arrays. For the practical aspect, our modification can be applied to any gap sequence, and we show that Ciura’s gap sequence, which is known to have good practical performance, is also practically effective when our modified Shell sort is applied. We compare our modified Shell sort with other sorting algorithms with the FHE over the torus (TFHE) library, and it is shown that this modified Shell sort has the best performance in running time among in-place sorting algorithms on homomorphic encryption scheme.

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.

This paper is intended to develop a bubble sort algorithm visualization for an Algorithm and Programming course in computer education. This learning model should encourage student's ability to learn the variety of sorting, such as selection sort, merge sort. etc. This research consists of 6 steps in visualization development such as need assessment, front-end analysis, design, development, implementation, and evaluation. During the testing step, the application is run and checked to confirm that it performs exactly what the author has intended and the students can learn bubble sorting algorithm by studying the visualization. Research findings indicated that the students increased their motivation and ability to create sorting visualitation application. Based on the data of process and product competencies taken from the evaluation, 85 per cent of the students were competent in sorting visualization programming and there were 15 per cent of the students were not competent.