Data Structure Sorting

Data Structures

RecurrencesDivide-and-Conquer Problems

problem

Divide

subproblemsubproblem subproblem

Conquer subproblem subproblem subproblem

Combine problem

RecurrencesDivide-and-Conquer Problems

•Binary Search

• Merge Sort

• Quick Sort

• Selection Sort

• Search Maximum

• Multiplying Large Integers

• Multiplying Chain of Matrices

Divide the problems into a number of sub problems.Conquer the sub problems by solving them recursively. If the sub-problem sizes are small enough, just solve the problems in a straight forward manner.Combine the solutions to the sub problems into the solution for the original problem.

Divide and Conquer Approach

Divide the n element sequence to be sorted into two subsequences of n/2 elements each.Conquer: Sort the two subsequences to produce the sorted answer.Combine: Merge the two sorted sub sequences to produce the sorted answer.

Merge Sort

Merge Sort Base Case: When the sequences to be sorted has length 1.

108 56 1214 89 3466Unsorted

108 56 1466

Divide

66 108

Divide

56Divide

56BCase

56Merge

Divide

56 66 10814

1289 34

Divide

Merge12

Divide12

BCase12

Divide

3412 89

14 34 8956 66 10812Sorted

Merge Sort AlgorithmMergeSort(A, i, j)

if j > i then

mid ← (i + j)/2

MergeSort(A, i, mid )

MergeSort(A, mid + 1, j )

Merge(A, i, mid, j )

Merge Algorithm

The basic merging algorithms takes

Two input arrays, A[] and B[],

An output array C[]

And three counters aptr, bptr and cptr. (initially set to the beginning of their respective arrays)

The smaller of A[aptr] and B[bptr] is copied to the next entry in C i.e. C[cptr].The appropriate counters are then advanced.When either of input list is exhausted, the remainder of the other list is copied to C.

Merge Algorithm

56 66 10814

3412 89

If A[aptr] < B[bptr]

C[cptr++] = A[aptr++]

C[cptr++] = B[bptr++]

14 > 12 therefore

C[cptr] = 12

Merge Algorithm

56 66 10814

3412 89

14 > 12 therefore

cptr++

C[cptr] = 12

Merge Algorithm

56 66 10814

3412 89

14 > 12 therefore

cptr++

bptr++

C[cptr] = 12

Merge Algorithm56 66 10814

3412 89

14 < 34 therefore

C[cptr] = 14

Merge Algorithm

56 66 10814

3412 89

14 < 34 therefore

cptr++

C[cptr] = 14

3412 89

14 < 34 therefore

cptr++

bptraptr

aptr++

C[cptr] = 14

3412 89

56 > 34 therefore

C[cptr] = 34

3412 89

56 > 34 therefore

cptr++

C[cptr] = 34

3412 89

56 > 34 therefore

cptr++

bptr++

C[cptr] = 34

3412 89

56 < 89 therefore

12 14 34

C[cptr] = 56

3412 89

56 < 89 therefore

cptr++

12 14 34

C[cptr] = 56

3412 89

56 < 89 therefore

cptr++

bptraptr

aptr++

12 14 34

C[cptr] = 56

3412 89

66 < 89 therefore

bptraptr

12 14 34 56

C[cptr] = 66

3412 89

66 < 89 therefore

cptr++

bptraptr

12 14 34

C[cptr] = 66

3412 89

66 < 89 therefore

cptr++

bptraptr

aptr++

12 14 34

C[cptr] = 66

3412 89

108 > 89 therefore

bptraptr

12 14 34 56 66

C[cptr] = 89

3412 89

108 > 89 therefore

cptr++

bptraptr

12 14 34 56 66

C[cptr] = 89

3412 89

108 > 89 therefore

cptr++

bptraptr

bptr++

12 14 34 56 66

C[cptr] = 89

3412 89

Array B is now finished, copy remaining elements of array A in array C

bptraptr

12 14 34 56 66 89

3412 89

Array B is now finished, copy remaining elements of array A in array C

bptraptr

12 14 34 56 66 89 108

Computation Tree

108 56 1214 89 3466

108 56 1466 1289 34

10866 56 14 1289 34

66 108 56 14 89 12

lg 7 = 3

Tree Depth = 3

Problem with Merge Sort

Merging two sorted lists requires linear extra memory.Additional work spent copying to the temporary array and back through out the algorithm.This problem slows down the sort considerably.

Quick Sort

Division of arrays in such a way that

The sorted sub arrays do not need to be later merged.This can be done by rearranging the elements in A(1:n) such that

A(i) <= A(j) for all i between 1 and m and all j between m+1 and n.

Thus the elements in A(1:m) and A(m+1: n) may be independently sorted. No merge is needed.

Quick Sort Algorithm

To sort an array S1. If the number of elements in S is 0 or 1, then return.2. Pick any element V in S. This is called pivot.3. Partition S-{V} (the remaining elements in S) into two

disjoint groups: S1= {x S – {V} | x <= V},

S2 = {x S – {V} | x >= V}4. Return {quickSort(S1) followed by v followed by

quickSort(S2) }

Quick Sort Partitioning

Rearrange the array such thatElement V (pivot) is in its final position None of elements in A[1] .. A[m] is > V None of elements in A[m+1] .. A[n] is < V

pivotelements lower than pivot

elements higherthan pivot

unsorted unsorted

Partition step/strategy is a design decision.

Picking the PivotBest strategy would be to pick the median of the array.Median of three partitioning.

Picking the Pivot:A = 8, 1, 4, 9, 6, 3, 5, 2, 7, 0

Pick three elements randomly and the median of these three numbers is the pivot.

1 4 39 6 58 2 7 0

Left = 8, Right = 0,

Center = (Left + Right)/2 = 4

• 4th elements of the array started with 0 is the pivot => 6

1 4 39 6 58 2 7 0

Replace the pivot with the last element

1 4 39 6 58 2 7 0

1 4 39 0 58 2 7 6

i jTwo indicies, i starts from the first element.

j starts from the second last element

Move all the smaller elements to the left and all the larger elements to the right (small and large is relative to the pivot).

1 4 39 0 58 2 7 6

A[ j ] > pivot therefore decrement j

1 4 39 0 58 2 7 6

A[i] > pivot

Swap A[i] and A[ j ]

1 4 39 0 58 2 7 6

A[ j ] < pivot

1 4 39 0 52 8 7 6

i jA[ i ] < pivot increment i until A[ i ] becomes

greater than pivot

1 4 39 0 52 8 7 6

jA[ i ] > pivot.A[ j ] > pivot therefore decrement j until A[ j ] < pivot

1 4 39 0 52 8 7 6

A[ j ] < pivot. Swap A[ i ] and A [ j ]

1 4 35 0 92 8 7 6

jA[ i ] < pivot increment i until A[ i ] becomes

greater than pivot

1 4 35 0 92 8 7 6

jA[ i ] > pivot.

A[ j ] > pivot therefore decrement j until A[ j ] < pivot

1 4 35 0 92 8 7 6

jA[ j ] < pivot.

i and j crosses each other therefore swap A[ i ] with pivot.

All less then pivot

1 4 35 0 62 8 7 9

All greater then pivot

All less then pivot

Apply same strategy on this sublist separately

1 4 35 0 62 8 7 9

All greater then pivot

Apply same strategy on this sublist separately

Quick Sort Algorithm

QuickSort(A, left, right) {if right > left then {

Pivot = Partition(A, left, right);QuickSort(A, left, pivot-1);QuickSort(A, pivot+1, right);

Partition AlgorithmPartition(a[ ], left, right ) { int i, j; int Pivot = (left+right) / 2; Swap(A[Pivot], A[right]);i = left; j = right - 1; Pivot = right;while ( i < j ) {

while( a[ i ] <= a[Pivot]) i++; while( a[ j ] >= a[Pivot]) j- -; if ( i < j ) SWAP(a[i], a[ j ]);

} Swap(A[ i ], A[Pivot])return i}

Selection SortAlgorithm

To sort an array A[1…n], consisting of n elements, the selection sort procedure is as follows. Scan array A[1..n] to find the minimum element.

Swap minimum element with A[1] Scan sub-array A[2..n] to find the minimum element.Swap minimum element with A[2] Scan sub-array A[3..n] to find the minimum element.

Swap minimum element with A[3]

Scan sub-array A[n-1.n] to find the minimum element. Swap minimum element with A[n-1]

At the end array A[1…n] is sorted

Data Structure Sorting

Education

Transcript of Data Structure Sorting

More sorting algorithms: Heap sort & Radix sort. Heap Data Structure and Heap Sort (Chapter 7.6)

Searching and Sorting - gitlab.cecs.anu.edu.au · Searching and Sorting. Search One of the most common problems for an algorithm to solve is to search for some data in some data structure.

CS235102 Data Structures Chapter 7 Sorting (Concentrating on Internal Sorting)

CSE373: Data Structure & Algorithms Lecture 21: More Comparison Sorting Aaron Bauer Winter 2014.

Protein Structure, Targeting and Sorting

CSE373: Data Structure & Algorithms Lecture 21: More Sorting and Other Classes of Algorithms Lauren Milne Summer 2015.

Data Structure Lecture 9 Sorting[1]

Compilation of Comments - globalchange.gov · III. Report Section Sorting Structure The comment sorting routine followed the Report section structure: Abstract Preface Executive Summary

Sorting Data

CENG 213 Data Structures Sorting Algorithms. CENG 213 Data Structures Sorting Sorting is a process that organizes a collection of data into either ascending.

(Data Structure) Chapter11 searching & sorting

Simple Sorting CSC220 Data Structure Winter 2004-5.

Horizontal Data Sorting

Searching and Sorting Techniques in Data Structure

CSE373: Data Structure & Algorithms Comparison Sorting

Algorithm Efficiency and Sorting Data Structure & Algorithm.

Classification of Data Structures:€¦ · Web viewUNIT – I INTRODUCTION TO DATA STRUCTURES, SEARCHING AND SORTING. Basic Concepts: Introduction to Data Structures: A data structure

Restricting and Sorting Data - Oracle Data Base

Sorting and Grouping Data

SORTING - Purdue University · Sorting Algorithms • Selection Sort ... using compartor c public void sort (Sequence S, Comparator c);} sorting 23 ... •ASet is a data structure