Merge Sort Research Articles

Encoding cardinality constraints using multiway merge selection networks

Boolean cardinality constraints (CCs) state that at most (at least, or exactly) k out of n propositional literals can be true. We propose a new, arc-consistent, easy to implement and efficient encoding of CCs based on a new class of selection networks. Several comparator networks have been recently proposed for encoding CCs and experiments have proved their efficiency (Abío et al. 2013, Asín et al. Constraints 12(2): 195–221, 2011, Codish and Zazon-Ivry 2010, Eén and Sörensson Boolean Modeling and Computation 2: 1–26, 2006). In our construction we use the idea of the multiway merge sorting networks by Lee and Batcher (1995) that generalizes the technique of odd-even sorting ones by merging simultaneously more than two subsequences. The new selection network merges 4 subsequences in that way. Based on this construction, we can encode more efficiently comparators in the combine phase of the network: instead of encoding each comparator separately by 3 clauses and 2 additional variables, we propose an encoding scheme that requires 5 clauses and 2 variables on average for each pair of comparators. We also extend the model of comparator networks so that the basic components are not only comparators (2-sorters) but more general m-sorters, for m ∈ {2, 3, 4}, that can also be encoded efficiently. We show that with small overhead (regarding implementation complexity) we can achieve a significant improvement in SAT-solver runtime for many test cases. We prove that the new encoding is competitive to the other state-of-the-art encodings.

Array sort: an adaptive sorting algorithm on multi‐thread

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.

Fully Flexible Parallel Merge Sort for Multicore Architectures

The development in multicore architectures gives a new line of processors that can flexibly distribute tasks between their logical cores. These need flexible models of efficient algorithms, both fast and stable. A new line of efficient sorting algorithms can support these systems to efficiently use all available resources. Processes and calculations shall be flexibly distributed between cores to make the performance as high as possible. In this article we present a fully flexible sorting method designed for parallel processing. The idea we describe in this article is based on modified merge sort, which in parallel form is designed for multicore architectures. The novelty of this idea is in particular way of processing. We have developed a fully flexible method that can be implemented for a number of processors. The tasks are flexibly distributed between logical cores to increase the efficiency of sorting. The method preserves separation of concerns; therefore, each of the processors works separately without any cross actions and interruptions. The proposed method was described in theoretical way, examined in tests, and compared to other methods. The results confirm high efficiency and show that with each newly added processor sorting becomes faster and more efficient.

Toward a new approach for sorting extremely large data files in the big data era

The extensive amount of data and contents generated today will require a paradigm shift in processing and management techniques for these data. One of the important data processing operations is the data sorting. Using multiple passes in external merge sort has a great influence on speeding up the sorting of extremely large data files. Since in large files, the swapping time is dominant in many applications, algorithms that minimize the swapping operations are normally superior to those which only focus on CPU time optimizations. In sorting extremely large files, external algorithms, such as the merge sort, are normally used. It is shown that using multiple passes over the data set, as proposed in our algorithm, has resulted in a great improvement in the number of swaps, thus, reducing the overall sorting time. Moreover, the proposed technique is suitable to be used with the emerging parallelization techniques such as GPUs. The reported results show the superiority of the proposed technique for “CPU only” and hybrid CPU–GPU implementations.

Unisort: an Algorithm to Sort Uniformly Distributed Numbers in O(n) Time

In recent years, computer science specialists are faced with the challenge of processing massive amounts of data. To overcome this barrier, researchers have developed new techniques to process data in efficient ways. This paper aims to present an algorithm for sorting uniformly distributed numbers, called Unisort. Given a uniformly distributed array of numbers, the algorithm places the numbers into bins to obtain sorted sub-arrays. It then merges the sorted sub-arrays to obtain the final sorted array. This work demonstrates that if numbers are uniformly distributed, the algorithm is able to sort them in O(n) time. Furthermore, the algorithm can be generalized to numbers produced by any known distribution. The only requirement is to know the distribution a priori. However, in the worst case scenario, when the distribution is not known, the numbers may fall in the same bin. For the worst case, the algorithm becomes similar to merge sort. Experiments conducted to assess the performance level of the algorithm, in terms of time efficiency, show that it is faster than quicksort, heapsort and Bucket sort. The algorithm has broad applications in information technology, since almost every information system organizes data by sorting it.

Learning efficient logic programs

When machine learning programs from data, we ideally want to learn efficient rather than inefficient programs. However, existing inductive logic programming (ILP) techniques cannot distinguish between the efficiencies of programs, such as permutation sort (n!) and merge sort O(n;log;n). To address this limitation, we introduce Metaopt, an ILP system which iteratively learns lower cost logic programs, each time further restricting the hypothesis space. We prove that given sufficiently large numbers of examples, Metaopt converges on minimal cost programs, and our experiments show that in practice only small numbers of examples are needed. To learn minimal time-complexity programs, including non-deterministic programs, we introduce a cost function called tree cost which measures the size of the SLD-tree searched when a program is given a goal. Our experiments on programming puzzles, robot strategies, and real-world string transformation problems show that Metaopt learns minimal cost programs. To our knowledge, Metaopt is the first machine learning approach that, given sufficient numbers of training examples, is guaranteed to learn minimal cost logic programs, including minimal time-complexity programs.

On the effectiveness of virtual reality in the education of software engineering

AbstractThe popularity of virtual reality headsets have been rapidly increasing. With this technology, students can efficiently interact with the course content and learn the material faster than the traditional methodologies. In addition to this benefit, virtual reality devices also draw the attention of young generation and this helps to the widespread use of this technology among students. In this study, we investigate the use of virtual reality on the performance of computer engineering bachelor science (BS) students within the scope of Data Structures course and develop a software‐intensive system called “Virtual Reality Enhanced Interactive Teaching Environment” (VR‐ENITE). Specifically, we focus on the sorting algorithms such as selection sort, bubble sort, insertions sort, and merge sort which are relatively hard to be understood by the BS students at first glance. For the evaluation of VR‐ENITE, students were divided into two groups: a group which uses VR‐ENITE in addition to the traditional teaching material and the control group which utilizes from only the traditional material. In order to evaluate the performance of these two groups having 36 students in total, a multiple choice exam was delivered to all of them. According to the test results, students who used the VR‐ENITE system got 12% more successful results in average than the students who are in the control group. This study experimentally shows that VR‐ENITE which is based on virtual reality technology is effective for teaching software engineering courses and it has assistive capabilities for traditional teaching approaches.

Performance comparison analysis library communication cluster system using merge sort

Begins by using a single processor, to increase the speed of computing time, the use of multi-processor was introduced. The second paradigm is known as parallel computing, example cluster. The cluster must have the communication potocol for processing, one of it is message passing Interface (MPI). MPI have many library, both of them OPENMPI and MPICH2. Performance of the cluster machine depend on suitable between performance characters of library communication and characters of the problem so this study aims to analyze the comparative performances libraries in handling parallel computing process. The case study in this research are MPICH2 and OpenMPI. This case research execute sorting’s problem to know the performance of cluster system. The sorting problem use mergesort method. The research method is by implementing OpenMPI and MPICH2 on a Linux-based cluster by using five computer virtual then analyze the performance of the system by different scenario tests and three parameters for to know the performance of MPICH2 and OpenMPI. These performances are execution time, speedup and efficiency. The results of this study showed that the addition of each data size makes OpenMPI and MPICH2 have an average speed-up and efficiency tend to increase but at a large data size decreases. increased data size doesn’t necessarily increased speed up and efficiency but only execution time example in 100000 data size. OpenMPI has a execution time greater than MPICH2 example in 1000 data size average execution time with MPICH2 is 0,009721 and OpenMPI is 0,003895 OpenMPI can customize communication needs.

Parallel Processing of Sorting and Searching Algorithms Comparative Study

Recently, supercomputers structure and its software optimization have been popular subjects. Much of the software recently consumes a long period of time both to sort and search datasets, and thus optimizing these algorithms becomes a priority. In order to discover the most efficient sorting and searching algorithms for parallel processing units, one can compare CPU runtime as a performance index. In this paper, Quick, Bubble, and Merge sort algorithms have been chosen for comparison, as well as sequential and binary as search algorithms. Each one of the sort and search algorithms was tested in worst, average and best case scenarios. And each scenario was applied using multiple techniques (sequential, multithread, and parallel processing) on a various number of processors to spot differences and calculate speed up factor.The proposed solution aims to optimize the performance of a supercomputer focusing one-time efficiency; all tests were conducted by The IMAN1 supercomputer which is Jordan's first and fastest supercomputer.

Multi-objective Hybrid DE Algorithm for Solving VRPTW

For the characteristics of the Vehicle Routing Problem with Time Windows(VRPTW) ô€€€a multi-objective hybrid Differential Evolution algorithm for VRPTW is proposed. Firstly, through a linearly varying parameter controls the probability of choice of DE/rand/1 mutation strategy and DE/best/1 mutation strategy. Secondly, a crossover operation based on merge sort is designed. Finally, selection operations employ Pareto-dominated concepts and ring rules to rank individuals and output non-dominated solutions. The experimental results compared with single strategy DE algorithm and ABC algorithms show that the proposed algorithm is effective in solving the VRPTW.

Performance Comparison between Merge and Quick Sort Algorithms in Data Structure

In computer science field, one of the basic operation is sorting. Many sorting operations use intermediate steps. Sorting is the procedure of ordering list of elements in ascending or descending with the help of key value in specific order. Many sorting algorithms have been designed and are being used. This paper presents performance comparisons among the two sorting algorithms, one of them merge sort another one is quick sort and produces evaluation based on the performances relating to time and space complexity. Both algorithms are vital and are being focused for long period but the query is still, which of them to use and when. Therefore this research study carried out. Each algorithm resolves the problem of sorting of data with a unique method. This study offers a complete learning that how both of the algorithms perform operation and then distinguish them based on various constraints to come with outcome.

Analysis of Energy Consumption of Sorting Algorithms on Smartphones

Despite the improvement in hardware and technology, Limited Battery power in Smartphone is still challenging task. Battery lifetime of mobile phones is needed to be improved. As compare to CPU power, HDD capacity, RAM and other hardware components the improvement in battery power consumption and lifetime in the past years is very low. The battery power of a Smartphone may be prolonged by optimizing hardware or software. This paper presents an approach for saving energy through software by choosing the appropriate sorting algorithm. Energy consumption of sorting algorithms like Bubble sort, Insertion sort, Quick sort, Selection sort and Merge sort were measured. The results show that Quick sort is the most energy efficient sorting method on average cases. Bubble sort is the most energy consuming algorithm. Insertion sort is also energy efficient but as the number of input data items increase after a certain value Merge sort outperforms the Insertion sort. This work provides the general guideline to select appropriate sorting algorithm in development of energy efficient Smartphone application. A new term Energy Complexity is also introduced in this paper.

Design of memory efficient FIFO-based merge sorter

Design of memory efficient FIFO-based merge sorter

Performance tests on merge sort and recursive merge sort for big data processing

Merge sort algorithm is widely used in databases to organize and search for information. In the work the author describes some newly proposed not recursive version of the merge sort algorithm for large data sets. Tests of the algorithm confirm the effectiveness of the method and the stability of the proposed version.

Efficient computation of multivariate empirical distribution functions at the observed values

Consider the evaluation of model-based functions of cumulative distribution functions that are integrals. When the cumulative distribution function does not have a tractable form but simulation of the multivariate distribution is easily feasible, we can evaluate the integral via a Monte Carlo sample, replacing the model-based distribution function by the empirical distribution function. Given a simulation sample of size N, the naive method uses $$O(N^{2})$$ comparisons to compute the empirical distribution function at all N sample vectors. To obtain faster computational speed when N needs to be large to achieve a desired accuracy, we propose methods modified from the popular merge sort and quicksort algorithms that preserve their average $$O(N\log _{2}N)$$ complexity in the bivariate case. The modified merge sort algorithm can be extended to the computation of a d-dimensional empirical distribution function at the observed values with $$O(N\log _{2}^{d-1}N)$$ complexity. Simulation studies suggest that the proposed algorithms provide substantial time savings when N is large.

TiML: a functional language for practical complexity analysis with invariants

We present TiML (Timed ML), an ML-like functional language with time-complexity annotations in types. It uses indexed types to express sizes of data structures and upper bounds on running time of functions; and refinement kinds to constrain these indices, expressing data-structure invariants and pre/post-conditions. Indexed types are flexible enough that TiML avoids a built-in notion of ≴size,≵ and the programmer can choose to index user-defined datatypes in any way that helps her analysis. TiML's distinguishing characteristic is supporting highly automated time-bound verification applicable to data structures with nontrivial invariants. The programmer provides type annotations, and the typechecker generates verification conditions that are discharged by an SMT solver. Type and index inference are supported to lower annotation burden, and, furthermore, big-O complexity can be inferred from recurrences generated during typechecking by a recurrence solver based on heuristic pattern matching (e.g. using the Master Theorem to handle divide-and-conquer-like recurrences). We have evaluated TiML's usability by implementing a broad suite of case-study modules, demonstrating that TiML, though lacking full automation and theoretical completeness, is versatile enough to verify worst-case and/or amortized complexities for algorithms and data structures like classic list operations, merge sort, Dijkstra's shortest-path algorithm, red-black trees, Braun trees, functional queues, and dynamic tables with bounds like m n log n . The learning curve and annotation burden are reasonable, as we argue with empirical results on our case studies. We formalized TiML's type-soundness proof in Coq.

An Efficient Programming Skeleton for Clusters of Multi-Core Processors

This paper proposes a divide and conquer skeleton which aids parallel system programmers by (1) reducing programming complexity, (2) shortening programming time, and (3) enhancing code efficiency. To do this, the proposed skeleton exploits three mechanisms of (1) work-stealing, and (2) communication/computation overlapping, and (3) architectural awareness in the proposed divide and conquer skeleton. Using the work-stealing mechanism, when a processing element reaches a low-load condition, the processing core fetches a new job from the waiting queue of other cores. The second mechanism uses special threads to enable the proposed skeleton to overlapping computations with communications. The third mechanism considers the architectural parameters of the host system e.g., size of L1 cache, network bandwidth, network latency to maximally match a divide and conquer problem with the proposed skeleton. To evaluate the proposed skeleton, three benchmarks of merge sort, fast Fourier transform, and standard matrix multiplication are developed by the proposed skeleton as well as customized programming. Experiments are done in both simulation and real implementation environments. The set of six codes are simulated using COTSon simulator and also implemented on 28 dual-core real system. Obtained results from simulations showed an average of 12.6% speed-up of the proposed skeleton as compared to the customized programming; obtained speed-up in real environment is 9.6%. Furthermore, programming aided by the proposed skeleton, is at least 70% faster than custom programming while this difference increases as the program volume increases.

Parallelization of Modified Merge Sort Algorithm

Modern architectures make possible development in new algorithms for large data sets and distributed computing. The newly proposed versions can benefit both from faster computing on the multi core architectures, and intelligent programming techniques that use efficient procedures available in the latest programming studios. Frequently used algorithms to sort arrays of data in NoSQL databases is merge sort, where as NoSQL we understand any database without typical SQL programming interpreter. The author describes how to use the parallelization of the sorting processes for the modified method of sorting by merging for large data sets. The subject of this research is the claim that the parallelization of the sorting method is faster and beneficial for multi-core systems. Presented results show how the number of processors influences the sorting performance. The results are presented in theoretical assumptions and confirmed in practical benchmark tests. The method is compared to other sorting methods like quick sort, heap sort, and merge sort to show potential efficiency.

One Approach for Parallel Algorithms Representation

This paper presents one approach for parallel algorithms representation. The proposed model is practice oriented and its name is AMPA (Agenda Model for Parallel Algorithms) due to basic blocks organization like a schedule. The model uses classical Master/Slave paradigm. One parallel merge sorting algorithm based on quick sort is presented with the discussed AMPA model and also three known representation approaches (description with natural language, pseudo code and PRAM). A survey of professional opinion about AMPA and other approaches is conducted. The results show that most of the interviewed people choose AMPA as the best way to understand the algorithm.

A COMPARATIVE STUDY OF VARIOUS TYPES OF SORTING TECHNIQUES

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.