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

10866

Divide

66

Divide

66

BCase

66

Merge

108

Divide

108

BCase

108

Merge

66 108

Merge

56 14

Divide

56Divide

56BCase

56Merge

14

Divide

14

BCase

14

Merge

14 56

Merge

56 66 10814

Merge

1289 34

Divide

1289

Divide

89

Divide

89

BCase

89

Merge12

Divide12

BCase12

Merge

8912

Merge

34

Divide

34

BCase

34

Merge

3412 89

Merge

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

A[]

aptr

3412 89

B[]

bptr

If A[aptr] < B[bptr]

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

Else

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

14 > 12 therefore

C[]

cptr

C[cptr] = 12

12

Merge Algorithm

56 66 10814

A[]

aptr

3412 89

B[]



Else


14 > 12 therefore

cptr++

cptr

C[]

bptr

C[cptr] = 12

12

Merge Algorithm

56 66 10814

A[]

aptr

3412 89

B[]



Else


14 > 12 therefore

cptr++

cptr

C[]

bptr

bptr++

C[cptr] = 12

12

Merge Algorithm56 66 10814

A[]

aptr

3412 89

B[]



Else


14 < 34 therefore

cptr

C[]

bptr

12

C[cptr] = 14

14

Merge Algorithm

56 66 10814

A[]

aptr

3412 89

B[]



Else


14 < 34 therefore

cptr++

cptr

C[]

bptr

12

C[cptr] = 14

14


A[]

3412 89

B[]



Else


14 < 34 therefore

cptr++

cptr

C[]

bptraptr

aptr++

12

C[cptr] = 14

14


A[]

aptr

3412 89

B[]



Else


56 > 34 therefore

cptr

C[]

bptr

12 14

C[cptr] = 34

34


A[]

aptr

3412 89

B[]



Else


56 > 34 therefore

cptr++

cptr

C[]

bptr

12

C[cptr] = 34

14 34


A[]

aptr

3412 89

B[]



Else


56 > 34 therefore

cptr++

cptr

C[]

bptr

bptr++

12

C[cptr] = 34

14 34


A[]

aptr

3412 89

B[]



Else


56 < 89 therefore

cptr

C[]

bptr

12 14 34

C[cptr] = 56

56


A[]

aptr

3412 89

B[]



Else


56 < 89 therefore

cptr++

cptr

C[]

bptr

12 14 34

C[cptr] = 56

56


A[]

3412 89

B[]



Else


56 < 89 therefore

cptr++

cptr

C[]

bptraptr

aptr++

12 14 34

C[cptr] = 56

56


A[]

3412 89

B[]



Else


66 < 89 therefore

cptr

C[]

bptraptr

12 14 34 56

C[cptr] = 66

66


A[]

3412 89

B[]



Else


66 < 89 therefore

cptr++

cptr

C[]

bptraptr

12 14 34

C[cptr] = 66

56 66


A[]

3412 89

B[]



Else


66 < 89 therefore

cptr++

cptr

C[]

bptraptr

aptr++

12 14 34

C[cptr] = 66

56 66


A[]

3412 89

B[]



Else


108 > 89 therefore

cptr

C[]

bptraptr

12 14 34 56 66

C[cptr] = 89

89


A[]

3412 89

B[]



Else


108 > 89 therefore

cptr++

cptr

C[]

bptraptr

12 14 34 56 66

C[cptr] = 89

89


A[]

3412 89

B[]



Else


108 > 89 therefore

cptr++

cptr

C[]

bptraptr

bptr++

12 14 34 56 66

C[cptr] = 89

89


A[]

3412 89

B[]



Else


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

cptr

C[]

bptraptr

12 14 34 56 66 89


A[]

3412 89

B[]



Else


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

cptr

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

N = 7

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

i j

A[ j ] > pivot therefore decrement j

1 4 39 0 58 2 7 6

i j

A[i] > pivot


Swap A[i] and A[ j ]

1 4 39 0 58 2 7 6

i j

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

i j

1 4 39 0 52 8 7 6

i j

i

1 4 39 0 52 8 7 6

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


i

1 4 39 0 52 8 7 6

j

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

i

1 4 35 0 92 8 7 6

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

greater than pivot


i

1 4 35 0 92 8 7 6

j

i

1 4 35 0 92 8 7 6

j

i

1 4 35 0 92 8 7 6

jA[ i ] > pivot.

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


i

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