Comparing sorting algorithm complexity based on control flow structure

In this chapter it will be shown that there can exist possible connections of Tsallis nonextensive definition of entropy (Tsallis, 1988) with the statistical analysis of simple insertion sort algorithm behaviour. This will be done basing on the connections between the idea of Turing machines (Turing, 1936) as a basis of considerations in computer science and especially in algorithmic processing and the proposal of non-equilibrium thermodynamics given by Constatino Tsallis (Tsallis, 1988; Tsallis, 2004) for indication of the possible existence of non-equilibrium states in the case of one sorting algorithm behaviour. Moreover, it will be also underlined that a some kind of paradigm change (Kuhn, 1962) is needed in the case of computer systems analysis because if one considers the computers as physical implementations of Turing machines should take into account that such implementations always need energy for their work (Strzalka, 2010) – Turing machine as a mathematical model of processing does not need energy. Because there is no (computer) machine that have the efficiency η = 100%, thus the problem of entropy production appears during their work. If we note that the process of sorting is also the introduction of order (obviously, according to a given appropriate relation) into the processed set (sometimes sorting is considered as an ordering (Knuth, 1997)), thus if one orders it must decrease the entropy in sorted set and increase it somewhere else (outside the Turing machine – in physical world outside its implementation). The connections mentioned above will be given basing on the analysis of insertion sorting, which behaviour for some cases can lead to the levels of entropy production that can be considered in terms of non-extensivity. The presented deliberations can be also related to the try of finding a new thermodymical basis for important part of authors' interest, i.e., the physics of computer processing.

In the past, pseudo code guidelines and intricate blackboard visuals were used to teach methods. This makes visualization technology a useful teaching tool for both students and teachers. In this assignment, we developed an algorithm visualizer. A sorting visualizer and a route finder are also provided. This project intends to provide a platform that could be used to understand better these ideas as well as to illustrate the uses of these various methodologies. As a foundation for learning algorithm design and analysis, Dijkstra's, A*, Deep First Search, Broadness First Search, Rapid Sort, Stack Sort, Sorting Algorithm, Bubble Sort, and other fundamental algorithms are commonly used. Google Street view and web searches are only two examples of software that uses these techniques and that we are using on a daily basis. As a consequence, we made an effort to create a tool that makes use of HTML, CSS, Express's, and other tools to graphically depict how these algorithms work. Our objective is to simplify the algorithm such that basic computer science students may comprehend it via a sequence of graphical stages.

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.

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 a classic problem that has been studied for decades. From the beginning of computing, many Sorting algorithms have been investigated. Bubble sort is a very common and powerful sorting technique used in different applications. For high speed data processing, we need faster and efficient environment for any sorting algorithm. In this purpose, FPGA based hardware accelerators can show better performance for high speed data processing than the general purpose processors. In this paper, the sequential and parallel bubble sort algorithm is implemented using FPGA. We show that parallel implementation of Bubble sort algorithm is almost 10 times faster than that of sequential implementation for 20 different data inputs. However, this implementation is faster for more data inputs.

This paper presents the study of implementation and performance in sorting process, using two different algorithms, namely Insertion Sort and Merge Sort. In the first stage, the two algorithms were implemented in C++ language to sort several numbers typed by a user. In the second stage, the source codes for those algorithms were modified to enable sorting randomly generated numbers with the amount as requested by the user. To find out how well they performed in sorting out the data, therefore in the last stage the two algorithms were tested to sort random numbers with predetermined amount ranges and the results were compared. From the experiments performed, merge sort algorithm had shown a better performance, particularly in a large number of data (> 10000). Insertion sort algorithm has the advantage in lower complexity algorithm, notably in the best case condition and since it does not use recursion routines in sorting process, hence it does not require as much storage space or memory as needed by merge sort algorithm.

Abstract— Aim/Background This study aims to systematically evaluate the practical runtime performance of the Insertion Sort algorithm across six widely used programming languages: C, C++, Go, Java, PHP, and Python. While Insertion Sort’s theoretical time complexity is well established, real-world execution performance may differ significantly due to variations in language paradigms, compilation strategies, and runtime environments. The research focuses on identifying how language-specific characteristics influence actual execution time. Methods The Insertion Sort algorithm was implemented uniformly in all six languages using a shared pseudocode to ensure consistency. Experiments were conducted under controlled conditions using input sizes of 1K, 10K, and 100K elements. Each dataset was tested with four different data arrangements: ascending, descending, nearly sorted, and random. Runtime measurements were collected and compared. Additionally, a Relative Execution Time Ratio (RETR) metric was introduced to provide a normalized and quantitative comparison of performance across languages. Results The experimental findings show clear performance differences among the programming languages. Go demonstrated the fastest runtimes across most scenarios, benefiting from its efficient compiled execution model. Java performed second-best, leveraging just-in-time (JIT) compilation and runtime optimizations. C and C++ showed moderate performance, influenced by compiler optimization levels and memory management mechanisms. PHP and Python exhibited significantly slower execution times, particularly for large and poorly ordered datasets, mainly due to interpreter overhead and runtime inefficiencies. The RETR metric effectively highlighted these relative performance gaps. Conclusion The study confirms that programming language choice significantly impacts real-world algorithm performance, even for well-understood algorithms like Insertion Sort. Compiled languages with efficient runtime optimizations generally outperform interpreted languages, especially for larger datasets. These results emphasize the importance of selecting appropriate programming languages for performance-critical applications and aligning algorithm implementation with both data characteristics and execution environments.

Bubble sort algorithm and its variants are discussed in detail. Bubble sort algorithm is the slowest one in application; improved bubble sort algorithm is superior to it because of the introduction of flag variant and the forward movement of end index; improved bubble sort algorithm moves the end index more quickly; bidirectional bubble sort algorithm quickly moves the end index forwards and the start index backwards at the same time. In all these algorithms, bidirectional bubble sort algorithm is especially suitable to those sequence parts items of which are already in expected order. Bidirectional bubble sort algorithm is of great significance and has the highest efficiency.

Complex time series are a concatenation of quasi-periodic time series, e.g. electrocardiogram (ECG) and capnogram. The complexity lies in the fact that these series usually composed of different number of periods, of different lengths that might be shifted/scaled on the time/magnitude axis. Due to this complexity, time series matching is rendered more difficult. The Shape Exchange Algorithm (SEA) and its derivates are currently the only algorithms that can effectively match this type of time series. However, SEA usefulness is limited only to small time series due to its quadratic temporal complexity. In this paper, an accelerated version of the SEA method is proposed that has a linear computational complexity. The new method is referred to by the acronym FastSEA. It is based on more efficient and yet simple sorting algorithm that is Counting Sort Algorithm. We have evaluated the new developed FastSEA method on ECG signals, selected from (MIT-BIH) public database. The experimental results show that FastSEA outperforms SEA in terms of efficiency by time reduction up to 99 % without loss with respect to SEA in terms of effectiveness. Also, FastSEA is found to be comparable to previously published speed up techniques for SEA: ASEAL and FANSEA, besides it obviously being more interesting than the famous DTW method, with no loss in accuracy. As a result, the proposed FastSEA is able to align very long time series in very short periods of time. Needless is to mention that FastSEA inherits the ability of SEA of being suitable for many applications, such as time series diagnosis and person identification using ECG, etc.

In this paper we analyze the algorithms expressed as a system of recurrence equations. The algorithms are called 2*1 output algorithms if two output values of one function (variable identification) are specified by the system of recurrence equations for each index point in the algorithm. The algorithm is in free form if the indexes of these two values are not dependent. Two standard classes are determined by this criteria: the nearest neighbour and the all pair form. For example the sorting algorithm can be expressed in the all pair form i.e., the linear insertion algorithm or in the nearest neighbour form i.e., the bubble sort algorithm. However these algorithms are different in their nature. A procedure to eliminate the computational broadcast for the all pair 2*1output algorithm has been proposed by the authors in [1]. The result obtained by implementing this procedure was a localized form of the algorithm and a system of uniform recurrence equations by eliminating the computational and data broadcast. So he data dependence method can be efficiently used for parallel implementations. The proposed procedure cannot be implemented directly on the nearest neighbour form algorithms. Here we show how the algorithm can be restructured into a form where the computational and data broadcast can be eliminated. These transformations result in localized algorithms. A few examples show how these algorithms can be implemented on processor arrays. For example, the Gentleman Kung triangular array [2] can be used for solving the QR decomposition algorithm for both forms of the algorithm. The implementations differ in the order of the data flow and the processor operation. We show that the implementation of the nearest neighbour algorithm is even better than the standard one.

Texas Instruments development kits have a wide application in practical and scientific experiments due to their small size, processing power, available booster packs, and compatibility with different environments. The most popular integrated development environments for programming these development kits are Energia and Code Composer Studio. Unfortunately, there are no existing studies that compare the benefits and drawbacks of these environments and their performances. Conversely, the performances of the FreeRTOS environment are well-explored, making it a suitable baseline for embedded systems execution. In this paper, we performed the experimental evaluation of the performance of Texas Instruments MSP-EXP432P401R when using Energia, Code Composer Studio, and FreeRTOS for program execution. Three different sorting algorithms (bubble sort, radix sort, merge sort) and three different search algorithms (binary search, random search, linear search) were used for this purpose. The results show that Energia sorting algorithms outperform other environments with a maximum of 400 elements. On the other hand, FreeRTOS search algorithms far outperform other environments with a maximum of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathbf{2 5 5, 0 0 0}$</tex> elements (whereas this maximum was <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathbf{1 0, 0 0 0}$</tex> elements for other environments). Code Composer Studio resulted in the largest processing time, which indicates that the lowlevel registry editing performed in this environment leads to significant performance issues.

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.

Complexity is developed to demonstrate feasible metrics for process obtaining objectives and quantifiable measurement, which may have numerous valuable applications in schedule and budget planning, cost estimation and optimal personnel task assignments a particular software. Also it aids the developer and practitioners in evaluating the software complexity due to its simplicity, which serves both as an analyzer and as a predicator in quantitative software engineering. In this research work, the Halstead complexity metrics were applied to three sorting algorithms and C-Sharp programming language was used to implement them. The results shows the variant performances of sorting algorithms and the best algorithm that can perform better in a defined system of application.

Merging by the parallel jump searching algorithm

In Indonesia, English is a compulsory subject for students. This course is an uninteresting subject and tends to be difficult for students to understand. Meanwhile, on the other hand, international issues are often discussed, namely English which is Students must know and be fluent in reading, writing and communication. The basic idea of research objectives, comparing the sorting process using two different algorithms, namely bubble sort and Merge Sort. The basic model of the research method Comparative Analysis of the Speed of the Shorting Method on Google Translate Indonesian-English Using Binary Search. Sorting, Sorted (ordered according to certain rules/rules), and the data is presented in sorted form, as said in dictionaries, and files in a directory. The algorithm used for sorting is bubble sort, which is an element comparison operation that is exchanged for other elements until the end of the data series is reached, until no more elements are swapped. Results for find out how well the performance speed of the bubble sort algorithm is in sorting data.