DOCSLIB.ORG

CSE 373: Analysis of Algorithms Lectures 5 ‒ 8 ( Correctness Of

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CSE 373: Analysis of Algorithms Lectures 5 ‒ 8 ( Correctness Of CSE 373: Analysis of Algorithms Lectures 5 ‒ 8 ( Correctness of Algorithms ) Rezaul A. Chowdhury Department of Computer Science SUNY Stony Brook Fall 2014 Insertion Sort Input: An array of numbers. Output: Elements̻ʞ 1 of ∶ ͢ ʟ ͢ rearranged in non-decreasing order of value. ̻ʞ 1 ∶ ͢ ʟ INSERTION -SORT ( A ) 1. for to 2. ͞ Ɣ 2 ̻. ͙͛ͨ͢͜͠ 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence 4. ̻ ͞ ̻ 1. ͞ Ǝ 1 5. while͝ Ɣ ͞ Ǝ 1 and 6. ͝ Ƙ 0 ̻ ͝ Ƙ ͙ͭ͟ 7. ̻ ͝ ƍ 1 Ɣ ̻ ͝ 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ Loop Invariants We use loop invariants to prove correctness of iterative algorithms A loop invariant is associated with a given loop of an algorithm, and it is a formal statement about the relationship among variables of the algorithm such that ― [ Initialization ] It is true prior to the first iteration of the loop ― [ Maintenance ] If it is true before an iteration of the loop, it remains true before the next iteration ― [ Termination ] When the loop terminates, the invariant gives us a useful property that helps show that the algorithm is correct Loop Invariants for Insertion Sort INSERTION -SORT ( A ) 1. for to 2. ͞ Ɣ 2 ̻. ͙͛ͨ͢͜͠ 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence 4. ̻ ͞ ̻ 1. ͞ Ǝ 1 5. while͝ Ɣ ͞ Ǝ 1 and 6. ͝ Ƙ 0 ̻ ͝ Ƙ ͙ͭ͟ 7. ̻ ͝ ƍ 1 Ɣ ̻ ͝ 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ Loop Invariants for Insertion Sort INSERTION -SORT ( A ) 1. for to Invariant͞ Ɣ 2 ̻. 1: ͙͛ͨ͢͜͠ consists of the elements ̻originally1. ͞ Ǝ 1 in , but in sorted order 2. ̻ 1. ͞ Ǝ 1 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence 4. ̻ ͞ ̻ 1. ͞ Ǝ 1 5. while͝ Ɣ ͞ Ǝ 1 and 6. ͝ Ƙ 0 ̻ ͝ Ƙ ͙ͭ͟ 7. ̻ ͝ ƍ 1 Ɣ ̻ ͝ 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ Loop Invariants for Insertion Sort INSERTION -SORT ( A ) 1. for to Invariant͞ Ɣ 2 ̻. 1: ͙͛ͨ͢͜͠ consists of the elements ̻originally1. ͞ Ǝ 1 in , but in sorted order 2. ̻ 1. ͞ Ǝ 1 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence 4. ̻ ͞ ̻ 1. ͞ Ǝ 1 5. while͝ Ɣ ͞ Ǝ 1 and Invariant͝ Ƙ 0 2: ̻ ͝ Ƙare ͙ͭ͟ each 6. ̻ ͝. ͞ ƚ ͙ͭ͟ 7. ̻ ͝ ƍ 1 Ɣ ̻ ͝ 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ Loop Invariant 1: Initialization At the start of the first iteration of the loop ( in lines ): Hence, subarray consists of a single element1 Ǝ 8 ͞, Ɣ which 2 is in fact the original̻ element1. ͞ Ǝ 1 in . ̻ 1 The subarray consisting of a single̻ 1 element is trivially sorted. Hence, the invariant holds initially. Loop Invariant 1: Maintenance We assume that invariant 1 holds before the start of the current iteration. Hence, the following holds: consists of the elements originally ̻in 1. ͞ Ǝ 1 , but in sorted order. For invariant 1 to hold before the̻ 1. start . ͞ Ǝ of 1 the next iteration, the following must hold at the end of the current iteration: consists of the elements originally in , but in sorted order. We̻ 1. use . ͞ invariant 2 to prove this. ̻ 1. ͞ Loop Invariant 1: Maintenance Loop Invariant 2: Initialization At the start of the first iteration of the loop ( in lines ): Hence, subarray consists of only two entries: 5 Ǝ 7and͝ Ɣ ͞. Ǝ 1 We know the following:̻ ͝. ͞ ̻ ͝ ̻ ͞ ― ( explicitly tested in line ) ― ̻ ͝ Ƙ ͙ͭ͟ ( from line ) 5 Hence, invariant̻ ͞ Ɣ ͙ͭ͟holds initially. 2 2 Loop Invariant 1: Maintenance Loop Invariant 2: Maintenance We assume that invariant 2 holds before the start of the current iteration. Hence, the following holds: are each . Since line copies which̻ is͝. .known ͞ to beƚ ͙ͭ͟ to which also held a value6 ̻, the͝ following holds at theƘ end ͙ͭ͟ of the̻ current͝ ƍ 1 iteration: areƚ ͙ͭ͟each . Before̻ ͝ ƍ 1. the . ͞ start of theƚ next ͙ͭ͟ iteration the check in line 5 ensures that invariant 2 continues to hold. ̻ ͝ Ƙ ͙ͭ͟ Loop Invariant 1: Maintenance Loop Invariant 2: Maintenance Observe that the inner loop ( in lines ) does not destroy any data because though the first iteration overwrites5 Ǝ 7 , that has already been saved in in line . ̻ ͞ ̻ ͞ As long as ͙ͭ͟is copied back2 into a location in without destroying any other element͙ͭ͟ in that subarray, we maintain̻ the1. ͞invariant that contains the first elements of the original list. ̻ 1. ͞ ͞ Loop Invariant 1: Maintenance Loop Invariant 2: Termination When the inner loop terminates we know the following. ― is sorted with each element ̻ 1. ͝ if , true by default ƙ ͙ͭ͟ if ͝ Ɣ 0, true because is sorted and ― ͝ Ƙis sorted 0 with each̻ element1. ͝ because̻ ͝ the ƙ ͙ͭ͟ following ̻held͝ ƍ before 1. ͞ was decremented: isƚ sorted ͙ͭ͟ with each item ― ͝ if the loop was̻ ͝. executed . ͞ at least once, and ƚ ͙ͭ͟ ̻ ͝ ƍ 1 Ɣ ̻ ͝ ƍotherwise2 ̻ ͝ ƍ 1 Ɣ ͙ͭ͟ Loop Invariant 1: Maintenance Loop Invariant 2: Termination When the inner loop terminates we know the following. ― is sorted with each element ― ̻ 1. ͝ is sorted with each elementƙ ͙ͭ͟ ― ̻ ͝ ƍ 1. ͞ or ƚ ͙ͭ͟ ̻ ͝ ƍ 1 Ɣ ̻ ͝ ƍ 2 ̻ ͝ ƍ 1 Ɣ ͙ͭ͟ Given the facts above, line 8 does not destroy any data, and gives us as the sorted permutation of the original data in . ̻ 1. ͞ ̻ 1. ͞ Loop Invariant 1: Termination When the outer loop terminates we know that . Hence, is the entire array ͞ Ɣ ̻.͙͛ͨ͢͜͠ƍ1, which is sorted and contains̻ the1. .original ͞ Ǝ 1 elements of ̻ 1. ̻. ͙͛ͨ͢͜͠. ̻ 1. ̻. ͙͛ͨ͢͜͠ Worst Case Runtime of Insertion Sort ( Upper Bound ) INSERTION -SORT ( A ) cost times 1. for to ͗ͥ ͢ 2. ͞ Ɣ 2 ̻. ͙͛ͨ͢͜͠ ͗ͦ 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence 0 ͢ Ǝ 1 4. ̻ ͞ ̻ 1. ͞ Ǝ 1 ͗ͨ 5. while͝ Ɣ ͞ Ǝ 1 and ͝ Ƙ 0 ̻ ͝ Ƙ ͙ͭ͟ ͗ͩ ȕ ͞ 6. ͦ%) ̻ ͝ ƍ 1 Ɣ ̻ ͝ ͗ͪ 7. ȕ ͞ Ǝ 1 ͗ͫ ͦ%) 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ ͗ͬ ͢ Ǝ 1 Running time, ͎ ͢ ƙ ͗ͥ͢ ƍ ͗ͦ ͢ Ǝ 1 ƍ ͗ͨ ͢ Ǝ 1 ) ) ) ƍ͗ͩ ∑%Ͱͦ ͞ ƍ ͗ͪ ∑%Ͱͦ ͞ Ǝ 1 ƍ ͗ͫ ∑%Ͱͦ ͞ Ǝ 1 ƍ ͗ͬ ͢ Ǝ 1 ͦ Ɣ 0.5 ͗ͩ ƍ ͗ͪ ƍ ͗ͫ ͢ ƍ 0.5 2͗ͥ ƍ 2͗ͦ ƍ 2͗ͨ ƍ ͗ͩ Ǝ ͗ͪ Ǝ ͗ͫ ƍ 2͗ͬ ͢ Ǝ ͗ͦ ƍ ͗ͨ ƍ ͗ͩ ƍ ͗ͬ ͦ ⇒ ͎ ͢ Ɣ ͉ ͢ Best Case Runtime of Insertion Sort ( Lower Bound ) INSERTION -SORT ( A ) cost times 1. for to ͗ͥ ͢ 2. ͞ Ɣ 2 ̻. ͙͛ͨ͢͜͠ ͗ͦ 3. //͙ͭ͟ insert Ɣ ̻ ͞ into the sorted sequence ̻ ͞ ̻ 1. ͞ Ǝ 1 0 4. ͢ Ǝ 1 ͗ͨ 5. while͝ Ɣ ͞ Ǝ 1 and ͗ͩ 6. ͝ Ƙ 0 ̻ ͝ Ƙ ͙ͭ͟ ̻ ͝ ƍ 1 Ɣ ̻ ͝ ͗ͪ 7. 0 ͗ͫ 8. ͝ Ɣ ͝ Ǝ 1 ̻ ͝ƍ1 Ɣ ͙ͭ͟ ͗ͬ ͢ Ǝ 1 Running time, ͎ ͢ ƚ ͗ͥ͢ ƍ ͗ͦ ͢ Ǝ 1 ƍ ͗ͨ ͢ Ǝ 1 ƍ͗ͩ ͢ Ǝ 1 ƍ ͗ͬ ͢ Ǝ 1 Ɣ ͗ͥ ƍ ͗ͦ ƍ ͗ͨ ƍ ͗ͩ ƍ ͗ͬ ͢ Ǝ ͗ͦ ƍ ͗ͨ ƍ ͗ͩ ƍ ͗ͬ ⇒ ͎ ͢ Ɣ Ω ͢ Selection Sort Input: An array of numbers. Output: Elements̻ʞ 1 of ∶ ͢ ʟ ͢ rearranged in non-decreasing order of value. ̻ʞ 1 ∶ ͢ ʟ SELECTION -SORT ( A ) 1. for to 2. //͞ Ɣfind 1 the̻. index ͙͛ͨ͢͜͠ of an entry with the smallest value in 3. ̻ ͞. ̻. ͙͛ͨ͢͜͠ 4. for͢͡͝ Ɣ ͞ to 5. if͝ Ɣ ͞ ƍ 1 ̻. ͙͛ͨ͢͜͠ 6. ̻ ͝ Ɨ ̻ ͢͡͝ 7. // swap͢͡͝ Ɣand ͝ 8. ̻ ͞ ̻ ͢͡͝ ̻ ͞ ↔ ̻ ͢͡͝ Selection Sort Input: An array of numbers. Output: Elements̻ʞ 1 of ∶ ͢ ʟ ͢ rearranged in non-decreasing order of value. ̻ʞ 1 ∶ ͢ ʟ SELECTION -SORT ( A ) 1. for to Invariant͞ Ɣ 1 ̻. 1: ͙͛ͨ͢͜͠ ? 2. // find the index of an entry with the smallest value in 3. ̻ ͞. ̻. ͙͛ͨ͢͜͠ 4. for͢͡͝ Ɣ ͞ to Invariant͝ Ɣ ͞ ƍ 1 2: ̻.? ͙͛ͨ͢͜͠ 5. if 6. ̻ ͝ Ɨ ̻ ͢͡͝ 7. // swap͢͡͝ Ɣand ͝ 8. ̻ ͞ ̻ ͢͡͝ ̻ ͞ ↔ ̻ ͢͡͝ Merging Two Sorted Subarrays Input: Two subarrays and in sorted order ( ). Output: A single sorted̻ʞ ͤ subarray ∶ ͥ ʟ ̻ ͥ ƍ 1:by ͦ merging the input subarrays.ͤ ƙ ͥ Ɨ ͦ ̻ʞ ͤ ∶ ͦ ʟ Merging Two Sorted Subarrays Input: Two subarrays and in sorted order ( ). Output: A single sorted̻ʞ ͤ subarray ∶ ͥ ʟ ̻ ͥ ƍ 1:by ͦ merging the input subarrays.ͤ ƙ ͥ Ɨ ͦ ̻ʞ ͤ ∶ ͦ ʟ Loop Invariant At the start of each iteration of the for loop of lines 12‒17 the following invariant holds: The subarray contains the smallest̻ ͤ: ͟elements Ǝ 1 of ͟ Ǝ ͤ and , ͆in 1:sorted ͥ͢ ƍ order.
Load more

Recommended publications
  • The Analysis and Synthesis of a Parallel Sorting Engine Redacted for Privacy Abstract Approv, John M
    AN ABSTRACT OF THE THESIS OF Byoungchul Ahn for the degree of Doctor of Philosophy in Electrical and Computer Engineering, presented on May 3. 1989. Title: The Analysis and Synthesis of a Parallel Sorting Engine Redacted for Privacy Abstract approv, John M. Murray / Thisthesisisconcerned withthe development of a unique parallelsort-mergesystemsuitablefor implementationinVLSI. Two new sorting subsystems, a high performance VLSI sorter and a four-waymerger,werealsorealizedduringthedevelopment process. In addition, the analysis of several existing parallel sorting architectures and algorithms was carried out. Algorithmic time complexity, VLSI processor performance, and chiparearequirementsfortheexistingsortingsystemswere evaluated.The rebound sorting algorithm was determined to be the mostefficientamongthoseconsidered. The reboundsorter algorithm was implementedinhardware asasystolicarraywith external expansion capability. The second phase of the research involved analyzing several parallel merge algorithms andtheirbuffer management schemes. The dominant considerations for this phase of the research were the achievement of minimum VLSI chiparea,design complexity, and logicdelay. Itwasdeterminedthattheproposedmerger architecture could be implemented inseveral ways. Selecting the appropriate microarchitecture for the merger, given the constraints of chip area and performance, was the major problem.The tradeoffs associated with this process are outlined. Finally,apipelinedsort-merge system was implementedin VLSI by combining a rebound sorter
    [Show full text]
  • Parallel Sorting Algorithms + Topic Overview
    + Design of Parallel Algorithms Parallel Sorting Algorithms + Topic Overview n Issues in Sorting on Parallel Computers n Sorting Networks n Bubble Sort and its Variants n Quicksort n Bucket and Sample Sort n Other Sorting Algorithms + Sorting: Overview n One of the most commonly used and well-studied kernels. n Sorting can be comparison-based or noncomparison-based. n The fundamental operation of comparison-based sorting is compare-exchange. n The lower bound on any comparison-based sort of n numbers is Θ(nlog n) . n We focus here on comparison-based sorting algorithms. + Sorting: Basics What is a parallel sorted sequence? Where are the input and output lists stored? n We assume that the input and output lists are distributed. n The sorted list is partitioned with the property that each partitioned list is sorted and each element in processor Pi's list is less than that in Pj's list if i < j. + Sorting: Parallel Compare Exchange Operation A parallel compare-exchange operation. Processes Pi and Pj send their elements to each other. Process Pi keeps min{ai,aj}, and Pj keeps max{ai, aj}. + Sorting: Basics What is the parallel counterpart to a sequential comparator? n If each processor has one element, the compare exchange operation stores the smaller element at the processor with smaller id. This can be done in ts + tw time. n If we have more than one element per processor, we call this operation a compare split. Assume each of two processors have n/p elements. n After the compare-split operation, the smaller n/p elements are at processor Pi and the larger n/p elements at Pj, where i < j.
    [Show full text]
  • View Publication
    Patience is a Virtue: Revisiting Merge and Sort on Modern Processors Badrish Chandramouli and Jonathan Goldstein Microsoft Research {badrishc, jongold}@microsoft.com ABSTRACT In particular, the vast quantities of almost sorted log-based data The vast quantities of log-based data appearing in data centers has appearing in data centers has generated this interest. In these generated an interest in sorting almost-sorted datasets. We revisit scenarios, data is collected from many servers, and brought the problem of sorting and merging data in main memory, and show together either immediately, or periodically (e.g. every minute), that a long-forgotten technique called Patience Sort can, with some and stored in a log. The log is then typically sorted, sometimes in key modifications, be made competitive with today’s best multiple ways, according to the types of questions being asked. If comparison-based sorting techniques for both random and almost those questions are temporal in nature [7][17][18], it is required that sorted data. Patience sort consists of two phases: the creation of the log be sorted on time. A widely-used technique for sorting sorted runs, and the merging of these runs. Through a combination almost sorted data is Timsort [8], which works by finding of algorithmic and architectural innovations, we dramatically contiguous runs of increasing or decreasing value in the dataset. improve Patience sort for both random and almost-ordered data. Of Our investigation has resulted in some surprising discoveries about particular interest is a new technique called ping-pong merge for a mostly-ignored 50-year-old sorting technique called Patience merging sorted runs in main memory.
    [Show full text]
  • From Merge Sort to Timsort Nicolas Auger, Cyril Nicaud, Carine Pivoteau
    Merge Strategies: from Merge Sort to TimSort Nicolas Auger, Cyril Nicaud, Carine Pivoteau To cite this version: Nicolas Auger, Cyril Nicaud, Carine Pivoteau. Merge Strategies: from Merge Sort to TimSort. 2015. hal-01212839v2 HAL Id: hal-01212839 https://hal-upec-upem.archives-ouvertes.fr/hal-01212839v2 Preprint submitted on 9 Dec 2015 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Merge Strategies: from Merge Sort to TimSort Nicolas Auger, Cyril Nicaud, and Carine Pivoteau Universit´eParis-Est, LIGM (UMR 8049), F77454 Marne-la-Vall´ee,France fauger,nicaud,[email protected] Abstract. The introduction of TimSort as the standard algorithm for sorting in Java and Python questions the generally accepted idea that merge algorithms are not competitive for sorting in practice. In an at- tempt to better understand TimSort algorithm, we define a framework to study the merging cost of sorting algorithms that relies on merges of monotonic subsequences of the input. We design a simpler yet competi- tive algorithm in the spirit of TimSort based on the same kind of ideas. As a benefit, our framework allows to establish the announced running time of TimSort, that is, O(n log n).
    [Show full text]
  • An Efficient Implementation of Batcher's Odd-Even Merge
    254 IEEE TRANSACTIONS ON COMPUTERS, VOL. c-32, NO. 3, MARCH 1983 An Efficient Implementation of Batcher's Odd- Even Merge Algorithm and Its Application in Parallel Sorting Schemes MANOJ KUMAR, MEMBER, IEEE, AND DANIEL S. HIRSCHBERG Abstract-An algorithm is presented to merge two subfiles ofsize mitted from one processor to another only through this inter- n/2 each, stored in the left and the right halves of a linearly connected connection pattern. The processors connected directly by the processor array, in 3n /2 route steps and log n compare-exchange A steps. This algorithm is extended to merge two horizontally adjacent interconnection pattern will be referred as neighbors. pro- subfiles of size m X n/2 each, stored in an m X n mesh-connected cessor can communicate with its neighbor with a route in- processor array in row-major order, in m + 2n route steps and log mn struction which executes in t. time. The processors also have compare-exchange steps. These algorithms are faster than their a compare-exchange instruction which compares the contents counterparts proposed so far. of any two ofeach processor's internal registers and places the Next, an algorithm is presented to merge two vertically aligned This executes subfiles, stored in a mesh-connected processor array in row-major smaller of them in a specified register. instruction order. Finally, a sorting scheme is proposed that requires 11 n route in t, time. steps and 2 log2 n compare-exchange steps to sort n2 elements stored Illiac IV has a similar architecture [1]. The processor at in an n X n mesh-connected processor array.
    [Show full text]
  • Sequential Merge Sort 2 Let's Make Mergesort Parallel
    CSE341T/CSE549T 09/15/2014 Merge Sort Lecture 6 Today we are going to turn to the classic problem of sorting. Recall that given an array of numbers, a sorting algorithm permutes this array so that they are arranged in an increasing order. You are already familiar with basics of the sorting algorithm we are learning today, but we will see how to make it parallel today. 1 Reminder: Sequential Merge Sort As a reminder, here is the pseudo-code for sequential Merge Sort. MergeSort(A; n) 1 if n = 1 2 then return A 3 Divide A into two Aleft and Aright each of size n=2 0 4 Aleft =MERGESORT(Aleft; n=2) 0 5 Aright =MERGESORT(Aright; n=2) 6 Merge the two halves into A0 7 return A0 The running time of the merge procedure is Θ(n). The overall running time (work) of the entire computation is W (n) = 2W (n=2) + Θ(n) = Θ(n lg n). 2 Let’s Make Mergesort Parallel The most obvious thing to do to make the merge sort algorithm parallel is to make the recursive calls in parallel. 1 MergeSort(A; n) 1 if n = 1 2 then return A 3 Divide A into two Aleft and Aright each of size n=2 0 4 Aleft spawn MERGESORT(Aleft; n=2) 0 5 Aright MERGESORT(Aright; n=2) 6 sync 7 Merge the two halves into A0 8 return A0 The work of the algorithm remains unchanged. What is the span? The recurrence is SMergeSort(n) = SMergeSort(n=2) + Smerge(n) Since we are merging the arrays sequentially, the span of the merge call is Θ(n) and the recurrence solves to SMergeSort(n) = Θ(n).
    [Show full text]
  • An Efficient Methodology to Sort Large Volume of Data
    INTERNATIONAL JOURNAL OF SCIENTIFIC & TECHNOLOGY RESEARCH VOLUME 9, ISSUE 03, MARCH 2020 ISSN 2277-8616 An Efficient Methodology to Sort Large Volume of Data S.Bharathiraja, G.Suganya, M.Premalatha, R.Kumar, Sakkaravarthi Ramanathan Abstract—Sorting is a basic data processing technique that is used in all day-day applications. To cope up with technological advancement and extensive increase in data acquisition and storage, Sorting requires improvement to minimize time taken for processing, response time and space required for processing. Various sorting techniques have been proposed by researchers but the applicability of those techniques for large volume of data is not assured. The main focus of this work is to propose a new sorting technique titled Neutral Sort, to reduce the time taken for sorting and decrease the response time for a large volume of data. Neutral Sort is designed as an enhancement to Merge Sort. The advantages and disadvantages of existing techniques in terms of their performance, efficiency and throughput are discussed and the comparative study shows that Neutral sort drastically reduces time taken for sorting and hence reduces the response time. Index Terms—Chunking, Banding, Sorting, Efficiency, Merge sort, Bigdata Sorting, Neutral Sort. —————————— —————————— 1 INTRODUCTION N data science, ordering of elements is very much useful in divided chunks may already be in sorted manner and hence I various applications and data base querying. Different doesn’t need further split, we have proposed a modified approaches have been proposed by researchers for Merge sort algorithm titled “Neutral sort” to reduce time performing the sorting operation effectively based on the type complexity and hence to reduce response time.
    [Show full text]
  • Parallel Techniques
    Algorithms and Applications Evaluating Algorithm Cost Processor-time product or cost of a computation can be defined as: Cost = execution time * total number of processors used Cost of a sequential computation simply its execution time, ts. Cost of a parallel computation is tp * n. Parallel execution time, tp, is given by ts/S(n). Cost-Optimal Parallel Algorithm One in which the cost to solve a problem on a multiprocessor is proportional to the cost (i.e., execution time) on a single processor system. Can be used to compare algorithms. Parallel Algorithm Time Complexity Can derive the time complexity of a parallel algorithm in a similar manner as for a sequential algorithm by counting the steps in the algorithm (worst case) . Following from the definition of cost-optimal algorithm But this does not take into account communication overhead. In textbook, calculated computation and communication separately. Sorting Algorithms - Potential Speedup O(nlogn) optimal for any sequential sorting algorithm without using special properties of the numbers. Best we can expect based upon a sequential sorting algorithm using n processors is Has been obtained but the constant hidden in the order notation extremely large. Also an algorithm exists for an n-processor hypercube using random operations. But, in general, a realistic O(logn) algorithm with n processors not be easy to achieve. Sorting Algorithms Reviewed Rank sort (to show that an non-optimal sequential algorithm may in fact be a good parallel algorithm) Compare and exchange operations (to show the effect of duplicated operations can lead to erroneous results) Bubble sort and odd-even transposition sort Two dimensional sorting - Shearsort (with use of transposition) Parallel Mergesort Parallel Quicksort Odd-even Mergesort Bitonic Mergesort Rank Sort The number of numbers that are smaller than each selected number is counted.
    [Show full text]
  • Mergesort, Quicksort Oct
    COMP 250 Fall 2017 13 - Recursive algorithms 3: mergesort, quicksort Oct. 6, 2017 Mergesort In lecture 7, we saw three algorithms for sorting a list of n items. We saw that, in the worst case, all of these algorithm required O(n2) operations. Such algorithms will be unacceptably slow if n is large. To make this claim more concrete, consider that if n = 220 ≈ 106 i.e one million, then n2 ≈ 1012. How long would it take a program to run that many instructions? Typical processors run at about 109 basic operations per second (i.e. GHz). So a problem that takes in the order of 1012 operations would require thousands of seconds of processing time. ( Having a multicore machine with say 4 processors only can speed things up by a factor of 4 { max { which doesn't change the argument here. ) Today we consider an alternative sorting algorithm that is much faster that these earlier O(n2) algorithms. This algorithm is called mergesort. Here is the idea. If the list has just one number (n = 1), then do nothing. Otherwise, partition the list of n elements into two lists of size about n=2 elements each, sort the two individual lists (recursively, using mergesort), and then merge the two sorted lists. For example, suppose we have a list < 8; 10; 3; 11; 6; 1; 9; 7; 13; 2; 5; 4; 12 > : We partition it into two lists < 8; 10; 3; 11; 6; 1 > < 9; 7; 13; 2; 5; 4; 12 > : and sort these (by applying mergesort recursively): < 1; 3; 6; 8; 10; 11 > < 2; 4; 5; 7; 9; 12; 13 > : Then, we merge these two lists to get < 1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13 > : Here is pseudocode for the algorithm.
    [Show full text]
  • Parallel Implementation of Sorting Algorithms
    IJCSI International Journal of Computer Science Issues, Vol. 9, Issue 4, No 3, July 2012 ISSN (Online): 1694-0814 www.IJCSI.org 164 Parallel Implementation of Sorting Algorithms Malika Dawra1, and Priti2 1Department of Computer Science & Applications M.D. University, Rohtak-124001, Haryana, India 2Department of Computer Science & Applications M.D. University, Rohtak-124001, Haryana, India Abstract Usage of memory and other computer resources is also a factor in classifying the A sorting algorithm is an efficient algorithm, which sorting algorithms. perform an important task that puts elements of a list in a certain order or arrange a collection of elements into a Recursion: some algorithms are either particular order. Sorting problem has attracted a great recursive or non recursive, while others deal of research because efficient sorting is important to may be both. optimize the use of other algorithms such as binary search. This paper presents a new algorithm that will Whether or not they are a comparison sort split large array in sub parts and then all sub parts are examines the data only by comparing two processed in parallel using existing sorting algorithms elements with a comparison operator. and finally outcome would be merged. To process sub There are several sorting algorithms available to parts in parallel multithreading has been introduced. sort the elements of an array. Some of the sorting algorithms are: Keywords: sorting, algorithm, splitting, merging, multithreading. Bubble sort 1. Introduction In the bubble sort, as elements are sorted they gradually “bubble” (or rise) to their proper location Sorting is the process of putting data in order; either in the array.
    [Show full text]
  • Strategies for Stable Merge Sorting
    Strategies for Stable Merge Sorting Sam Buss∗ Alexander Knop∗ Abstract relative order of pairs of entries in the input list. We introduce new stable natural merge sort algorithms, Information-theoretic considerations imply that any called 2-merge sort and α-merge sort. We prove upper and comparison-based sorting algorithm must make at least lower bounds for several merge sort algorithms, including log2(n!) ≈ n log2 n comparisons in the worst case. How- Timsort, Shiver's sort, α-stack sorts, and our new 2-merge ever, in many practical applications, the input is fre- and α-merge sorts. The upper and lower bounds have quently already partially sorted. There are many adap- the forms c · n log m and c · n log n for inputs of length n tive sort algorithms which will detect this and run faster comprising m runs. For Timsort, we prove a lower bound of on inputs which are already partially sorted. Natu- (1:5−o(1))n log n. For 2-merge sort, we prove optimal upper ral merge sorts are adaptive in this sense: they detect and lower bounds of approximately (1:089 ± o(1))n log m. sorted sublists (called \runs") in the input, and thereby We state similar asymptotically matching upper and lower reduce the cost of merging sublists. One very popular bounds for α-merge sort, when ' < α < 2, where ' is the stable natural merge sort is the eponymous Timsort of golden ratio. Tim Peters [25]. Timsort is extensively used, as it is in- Our bounds are in terms of merge cost; this upper cluded in Python, in the Java standard library, in GNU bounds the number of comparisons and accurately models Octave, and in the Android operating system.
    [Show full text]
  • Sorting with Gpus: a Survey Dmitri I
    1 Sorting with GPUs: A Survey Dmitri I. Arkhipov, Di Wu, Keqin Li, and Amelia C. Regan Abstract—Sorting is a fundamental operation in computer Our key findings are the following: science and is a bottleneck in many important fields. Sorting • Effective parallel sorting algorithms must use the faster is critical to database applications, online search and indexing, biomedical computing, and many other applications. The explo- access on-chip memory as much and as often as possible sive growth in computational power and availability of GPU as a substitute to global memory operations. coprocessors has allowed sort operations on GPUs to be done • Algorithmic improvements that used on-chip memory much faster than any equivalently priced CPU. Current trends and made threads work more evenly seemed to be more in GPU computing shows that this explosive growth in GPU effective than those that simply encoded sorts as primitive capabilities is likely to continue for some time. As such, there is a need to develop algorithms to effectively harness the power of GPU operations. GPUs for crucial applications such as sorting. • Communication and synchronization should be done at points specified by the hardware. Index Terms—GPU, sorting, SIMD, parallel algorithms. • Which GPU primitives (scan and 1-bit scatter in partic- ular) are used makes a big difference. Some primitive I. INTRODUCTION implementations were simply more efficient than others, In this survey, we explore the problem of sorting on GPUs. and some exhibit a greater degree of fine grained paral- As GPUs allow for effective hardware level parallelism, re- lelism than others.
    [Show full text]