Merge Sort Algorithm Research Articles

Heuristic and pattern based Merge Sort

Abstract The aim of this study is to present a stable and adaptable Merge Sort algorithm that uses the design patterns to reduce computational complexity of swaps and memory usage. The order of Settlement of elements recorded by design patterns and merging one element by another (first phase) replaced with chunk merging. This algorithm has been implemented by C++ programming language.

Several Incomplete Sort Algorithms for Getting the Median Value

To quickly get the median value of any given sequence is very important in many research fields. Some popular sort algorithms are discussed in this paper. Selection sort algorithm and bubble sort algorithm are redesigned as incomplete sort algorithms to quickly give the median value of randomly given sequence. In the new algorithms, only parts of the items in sequence need to be sorted to give the median value, then many data comparison and movement operation are reduced, and the speed of getting median value can be improved greatly. Besides, insertion sort algorithm and merge sort algorithm are analyzed thoroughly and found not suitable to be redesigned as incomplete sort algorithms for this purpose. At last, lots of experiments are done to compare the performance of incomplete selection sort algorithm and incomplete bubble sort algorithm. Experiment results and algorithm analysis show that incomplete selection sort algorithm perform very well in case of both short sequence and long sequence.

Optimal Sorting Algorithms for a Simplified 2D Array with Reconfigurable Pipelined Bus System

In recent years, many researchers have investigated optical interconnections as parallel computing. Optical interconnections are attractive due to their high bandwidth and concurrent access to the bus in a pipelined fashion. The Linear Array with Reconfigurable Pipelined Bus System (LARPBS) model is a powerful optical bus system that combines both the advantages of optical buses and reconfiguration. To increase the scalability of the LARPBS model, we propose a two-dimensional extension: a simplified two-dimensional Array with Reconfigurable Pipelined Bus System (2D ARPBS). While achieving better scalability, we show the effectiveness of this newly proposed model by designing two novel optimal sorting algorithms on this model. The first sorting algorithm is an extension of Leighton's seven-phase columnsort algorithm that eliminates the restriction of sorting only an r × s array, where r ? s2 , and sorts an n × n array in O(log n) time. The second one is an optimal multiway mergesort algorithm that uses a novel processor efficient two-way mergesort algorithm and a novel multiway merge scheme to sort n2 items in O(log n) time. Using an optimal sorting algorithm Pipelined Mergesort designed for the LARPBS model as a building block, we extend our research on parallel sorting on the LARPBS to a more scalable 2D ARPBS model and achieve optimality in both sorting algorithms.

Analysis of Parallel Merge Sort Algorithm

The parallel computing on loosely coupled architecture has been evolved now days because of the availability of fast, inexpensive processors and advancements in communication technologies. The aim of this paper is to evaluate the performance of parallel merge sort algorithm on loosely coupled architecture and compare it with theoretical analysis [1].The parallel computational time complexity is O (p) [3] using p processes and one element in each process. It has been found that there is no major difference between theoretical performance analysis and the actual result.

Scheduling and Routing of AMOs in an Intelligent Transport System

Autonomous moving objects (AMOs), such as automated guided vehicles (AGVs) and autonomous robots, have widely been used in the industry for decades. In an intelligent transport system with a great number of AMOs involved, it is important to eliminate potential congestion and deadlocks among AMOs to maintain a well-organized traffic flow. In this paper, we propose an algorithm that adapts bitonic merge sort algorithm for concurrent scheduling and routing of a great number (i.e., 4n 2) of AMOs on an ntimesn mesh topology of path network without congestion or deadlocks among AMOs during their moves. The results are tested by experiments with randomly generated data and the comparison of a related model.

GPU Local Triangulation: an interpolating surface reconstruction algorithm

AbstractA GPU capable method for surface reconstruction from unorganized point clouds without additional information, called GLT (GPU Local Triangulation), is presented. The main objective of this research is the generation of a GPU interpolating reconstruction based on local Delaunay triangulations, inspired by a pre‐existing reconstruction algorithm. Current graphics hardware accelerated algorithms are approximating approaches, where the final triangulation is usually performed through either marching cubes or marching tetrahedras. GPU‐compatible methods and data structures to perform normal estimation and the local triangulation have been developed, plus a variation of the Bitonic Merge Sort algorithm to work with multi‐lists. Our method shows an average gain of one order of magnitude over previous research.

A Rule-Based, Integrated Modelling Approach for Object-Oriented Systems

In this paper an integrated modelling approach for object-oriented systems is proposed. The integrated language consists of three layers. On the first layer UML class diagrams are used to define the structure of the modelled systems and OCL expressions specify queries, which do not modify the object configuration. On the second layer transformation rules model local state modifications of the system. On the third layer Nassi-Shneiderman diagrams describe complex control flows built over the rules and queries on the lower layers. The proposed integrated language is evaluated by a running example on modelling doubly linked lists and the mergesort algorithm.

Optimal and Practical Algorithms for Sorting on the PDM

The parallel disks model (PDM) has been proposed to alleviate the I/O bottleneck that arises in the processing of massive data sets. Sorting has been extensively studied on the PDM model due to the fundamental nature of the problem - several asymptotically optimal algorithms are known for sorting. Although randomization has been frequently exploited, most of the prior algorithms suffer from complications in memory layouts, implementation, restrictions in range of parameters, and laborious analysis. In this paper, we present a randomized mergesort algorithm based on a simple idea that sorts using an asymptotically optimal number of I/O operations with high probability and has all of the desirable features for practical implementation. In the second part of the paper, we also present several novel algorithms for sorting on the PDM that take only a small number of passes through the data. Recently, considerable interest has been shown by researchers in developing algorithms for problem sizes of practical interest and we are able to obtain several improvements and simplification, in particular for random input.

Quantum switching and quantum merge sorting

This paper proposes a quantum switching architecture that can dynamically permute each input quantum data to its destination port to avoid using the fully connected networks. In addition, in order to reduce the execution time of the quantum switching, an efficient quantum merge sorting (QMS) algorithm that provides a parallel quantum computation is also developed. The quantum switching utilizes the QMS algorithm as a subroutine so that the total running time can be reduced to polylogarithmic time. Furthermore, to evaluate the feasibility of the quantum switching, we also define three different kinds of performance factors that can be used to estimate the complexity in implementation and the time delay in execution for quantum instruments. From the evaluation results, it can be seen that the proposed quantum switching is feasible in practice.

List processing

This paper discusses a possible student project for use within the Data Structures and Algorithms treatment of linked lists. Students can explicitly compare the recursive list-oriented MergeSort algorithm with iterative list-oriented MergeSort algorithms (with O( n ) space overhead) including the "Natural MergeSort." The author's experimental results are shown for implementations in C and in Java.

Efficient unbalanced merge–sort

Sorting algorithms based on successive merging of ordered subsequences are widely used, due to their efficiency and to their intrinsically parallelizable structure. Among them, the merge–sort algorithm emerges indisputably as the most prominent method. In this paper we present a variant of merge–sort that proceeds through arbitrary merges between pairs of quasi-ordered subsequences, no matter which their size may be. We provide a detailed analysis, showing that a set of n elements can be sorted by performing at most n ⌊ log n ⌋ key comparisons. Our method has the same optimal asymptotic time and space complexity as compared to previous known unbalanced merge–sort algorithms, but experimental results show that it behaves significantly better in practice.

A Simple and Efficient Parallel Disk Mergesort

External sorting—the process of sorting a file that is too large to fit into the computer's internal memory and must be stored externally on disks—is a fundamental subroutine in database systems[G], [IBM]. Of prime importance are techniques that use multiple disks in parallel in order to speed up the performance of external sorting. The simple randomized merging (SRM ) mergesort algorithm proposed by Barve et al. [BGV] is the first parallel disk sorting algorithm that requires a provably optimal number of passes and that is fast in practice. Knuth [K,Section 5.4.9] recently identified SRM (which he calls ``randomized striping'') as the method of choice for sorting with parallel disks. In this paper we present an efficient implementation of SRM, based upon novel and elegant data structures. We give a new implementation for SRM's lookahead forecasting technique for parallel prefetching and its forecast and flush technique for buffer management. Our techniques amount to a significant improvement in the way SRM carries out the parallel, independent disk accesses necessary to read blocks of input runs efficiently during external merging. Our implementation is based on synchronous parallel I/O primitives provided by the TPIE programming environment[TPI]; whenever our program issues an I/O read (write) operation, one block of data is synchronously read from (written to) each disk in parallel. We compare the performance of SRM over a wide range of input sizes with that of disk-striped mergesort (DSM ), which is widely used in practice. DSM consists of a standard mergesort in conjunction with striped I/O for parallel disk access. SRM merges together significantly more runs at a time compared with DSM, and thus it requires fewer merge passes. We demonstrate in practical scenarios that even though the streaming speeds for merging with DSM are a little higher than those for SRM (since DSM merges fewer runs at a time), sorting using SRM is often significantly faster than with DSM (since SRM requires fewer passes). The techniques in this paper can be generalized to meet the load-balancing requirements of other applications using parallel disks, including distribution sort and multiway partitioning of a file into several other files. Since both parallel disk merging and multimedia processing deal with streams that get ``consumed'' at nonuniform and partially predictable rates, our techniques for lookahead based upon forecasting data may have relevance in video server applications.

A Framework for Simple Sorting Algorithms on Parallel Disk Systems

In this paper we present a simple parallel sorting algorithm and illustrate its application in general sorting, disk sorting, and hypercube sorting. The algorithm (called the (l,m) -mergesort (LMM)) is an extension of the bitonic and odd—even mergesorts. Literature on parallel sorting is abundant. Many of the algorithms proposed, though being theoretically important, may not perform satisfactorily in practice owing to large constants in their time bounds. The algorithm presented in this paper has the potential of being practical. We present an application to the parallel disk sorting problem. The algorithm is asymptotically optimal (assuming that N is a polynomial in M , where N is the number of records to be sorted and M is the internal memory size). The underlying constant is very small. This algorithm performs better than the disk-striped mergesort (DSM) algorithm when the number of disks is large. Our implementation is as simple as that of DSM (requiring no fancy data structures or prefetch techniques.) As a second application, we prove that we can get a sparse enumeration sort on the hypercube that is simpler than that of the classical algorithm of Nassimi and Sahni [16]. We also show that Leighton's columnsort algorithm is a special case of LMM.

The heap-mergesort

In this paper, we present a new mergesort algorithm which can sort n(= 2 h+1 − 1) elements using no more than n log 2(n+1) − ( 13 12 )n − 1 element comparisons in the worst case. This algorithm includes the heap (fine heap) creation phase as a pre-processing step, and for each internal node v, its left and right subheaps are merged into a sorted list of the elements under that node. Experimental results show that this algorithm requires only n log 2( n+1) − 1.2 n element comparisons in the average case. But it requires extra space for n LINK fields.

Stochastic analysis of the Merge-Sort algorithm

Stochastic analysis of the Merge-Sort algorithm

Simple randomized mergesort on parallel disks

We consider the problem of sorting a file of N records on the D-disk model of parallel I/O in which there are two sources of parallelism. Records are transferred to and from disk concurrently in blocks of B contiguous records. In each I/O operation, up to one block can be transferred to or from each of the D-disks in parallel. We propose a simple, efficient, randomized mergesort algorithm called SRM that uses a forecast-and-flush approach to overcome the inherent difficulties of simple merging on parallel disks. SRM exhibits a limited use of randomization and also has a useful deterministic version. Generalizing the technique of forecasting, our algorithm is able to read in, at any time, the ‘right’ block from any disk and using the technique of flushing, our algorithm evicts, without any I/O overhead, just the ‘right’ blocks from memory to make space for new ones to be read in. The disk layout of SRM is such that it enjoys perfect write parallelism, avoiding fundamental inefficiencies of previous mergesort algorithms. By analysis of generalized maximum occupancy problems we are able to derive an analytical upper bound on SRM's expected overhead valid for arbitrary inputs. The upper bound derived on expected I/O performance of SRM indicates that SRM is provably better than disk-striped mergesort (DSM) for realistic parameter values D, M and B. Average-case simulations show further improvement on the analytical upper bound. Unlike previously proposed optimal sorting algorithms, SRM outper-forms DSM even when the number D of parallel disks is small.

Formula omitted]-graphs: Scalable topology and design of balanced divide-and-conquer algorithms

A parallel implementation of binary, balanced divide-and-conquer is derived systematically from its functional specification. The implementation makes use of a new processor topology, called N -graph, and has the following properties: there are not more than 4 links per processor, the processor network is of an arbitrary fixed size, the load is balanced and all communications are local. A parallel mergesort algorithm is used to illustrate the derivation process and the parallel target program with message passing. Experiments on a 64-node transputer network are presented.

Generalized algorithm for parallel sorting on product networks

We generalize the well-known odd-even merge sorting algorithm, originally due to Batcher (1968), and show how this generalized algorithm can be applied to sorting on product networks. If G is an arbitrary factor graph with N nodes, its r-dimensional product contains N/sup r/ nodes. Our algorithm sorts N/sup r/ keys stored in the r-dimensional product of G in O(r/sup r/F(N)) time, where F(N) depends on G. We show that, for any factor graph G, F(N) is, at most, O(N), establishing an upper bound of O(r/sup 2/ N) for the time complexity of sorting N/sup r/ keys on any product network. For product networks with bounded r(e.g. for grids), this leads to the asymptotic complexity of O(N) to sort N/sup r/ keys, which is optimal for several instances of product networks. There are factor graphs for which F(N)=O(log/sup 2/ N), which leads to the asymptotic running time of O(log/sup 2/ N) to sort N/sup r/ keys. For networks with bounded N (e.g. in the hypercube N=2, fixed), the asymptotic complexity becomes O(r/sup 2/). We show how to apply the algorithm to several cases of well-known product networks, as well as others introduced recently. We compare the performance of our algorithm to well-known algorithms developed specifically for these networks, as well as others. The result of these comparisons led us to conjecture that the proposed algorithm is probably the best deterministic algorithm that can be found in terms of the low asymptotic complexity with a small constant.

Practical in-place mergesort

Two in-place variants of the classical mergesort algorithm are analysed in detail. The first, straightforward variant performs at most N log2 N + O(N) comparisons and 3N log2 N + O(N) moves to sort...

Bottom-up mergesort ? A detailed analysis

Though the behaviors of mergesort algorithms are basically known, the periodicity phenomena encountered in their analyses are not easy to deal with. In this paper closed-form expressions for the necessary number of comparisons are derived for the bottom-up algorithm, which adequately describe its periodic behavior. This allows us, among other things, to compare the top-down and bottom-up mergesort algorithms.