Lect11 Sorting

transcript

Lecture 11 Sorting

Aj. Khwunta KirimasthongSchool of Information

TechnologyMae Fah Luang University

1302251 Data Structures and Algorithms

Outline

Sorting Concept Sorting Algorithm

Selection Sort Insertion Sort Merge Sort Quick Sort

Sorting Concept

Sorting is the operation of arranging data in some given order, such as Ascending

the dictionary, the telephone book Descending

grade-point average for honor students

The sorted data can be numerical data or character data.

Sorting is one of the most common data-processing applications.

Sorting Concept (Cont.)

Sorting problemLet A be a sequence of n elements. Sorting A refers to the operation of rearranging the content of A so that they are increasing in order.

Input: A: the sequence of n numbers

Output: A: the reordering of the input sequence such that

1 2( , ,..., )na a a

1 2 na a a

Selection Sort

One of basic sorting algorithms Selection Sort works as follows:

First, find the smallest elements in the data sequence and exchange it with the element in the first position,

Then, find the second smallest element and exchange it with the element in the second position and

Continue in this way until the entire sequence is sorted.

Selection Sort Example5 2 4 6 1 3A

1 2 3 4 5 6

1 2 4 6 5 3A

1 2 3 4 5 6

1 2 4 6 5 3A(2) 1 2 3 4 5 6

1 2 3 6 5 4A(3)

1 2 3 4 5 6

1 2 3 4 5 6A(4)

1 2 3 4 5 6

1 2 3 4 5 6A(5) 1 2 3 4 5 6

1 2 3 4 5 6A(6)

1 2 3 4 5 6

Selection Sort Algorithm

Algorithm SelectionSort(A,n)Input: A: a sequence of n elements

n: the size of A

Output: A: a sorted sequence in ascending order

for i = 1 to n

min = ifor j = i+1 to n

if A[j] < A[min] thenmin = j

Swap(A,min,i)

Selection Sort Algorithm (Cont.)Algorithm: Swap(A,min,i)Input: A : a sequence of n elements

min: the position of the minimum value of A while considers at index i of A

i: the considered index of A

Output: exchange A[i] and A[min] temp = a[min]a[min] = a[i]a[i] = temp

Selection Sort Analysis

For i = 1, there are _(n-1)_ comparisons to find the first smallest element.

For i = 2, there are _(n-2)_ comparisons to find the second smallest element, and so on.

Accordingly,

(n-1) + (n-2) + (n-3) + … + 2 + 1 = = n(n-1)/2

The best case running time is ___(n2)__ The worst case running time is __ O(n2)__

Insertion Sort

To solve the sorting problem Insertion sort algorithm is almost as simple as

selection sort but perhaps more flexible. Insertion sort is the method people often

use for sorting a hand of cards.

Insertion Sort (Cont.)

Insertion sort uses an incremental approach: having the sorted subarray A[1…j-1], we insert the single element A[ j ] into its proper place and then we will get the sorted subarray A[ 1…j ]

pick up

Sorted order Unsorted order

5 2 4 6 1 3

key = A[j]

2 5 4 6 1 3

2 4 5 6 1 3

Insertion Sort Example

in-place sorted

5 2 4 6 1 3

1 2 3 4 5 6

2 4 5 6 1 3

1 2 4 5 6 3

1 2 3 4 5 6

in-place sorted

Insertion Sort Example (Cont.)

1 2 3 4 5 6

Insertion Sort Algorithm

Algorithm: INSERTION-SORT(A)Input: A : A sequence of n numbers Output: A : A sorted sequence in increasing order of array A

for j = 2 to length(A) key = A[j]//Insert A[j] into the sorted sequence A[1…j-

1] i = j-1while i > 0 and A[i] > key

A[i+1] = A[i]i = i-1

A[i+1] = key

Insertion Sort Analysis

The running – time of INSERTION-SORT depends on the size of input.

Insertion Sort Analysis (cont.)INSERTION-SORT(A) cost times

1. for j = 2 to length(A) c1

2. key = A[j] c2

3. //Insert A[j] into the sorted sequence A[1…j-1] 0

4. i = j-1 c4

5. while i > 0 and A[i] > key c5

6. A[i+1] = A[i] c6

7. i = i-1 c7

8. A[i+1] = key c8

Analysis of Insertion Sort (Cont.)

To Compute the total running time of INSERTION-

SORT, ( )T n

1 2 4 52

( ) ( 1) 0( 1) ( 1)n

T n c n c n n c n c t

6 7 82 2

( 1) ( 1) ( 1)n n

j jj j

c t c t c n

Best – case If input array is already sorted. Thus tj = 1

an + b for constant a and b

Base-case running time of INSERTION-SORT is

T(n) = c1n+c2(n-1)+(0)(n-1)+c4(n-1)+c5(n-1)+c6(0)+c7(0)+c8(n-1) = (c1+c2+c3+c4+c5+c8)n - (c2+c3+c4+c5+c8)

Worse – case If input array is in reverse sorted order. Thus tj = j

Worse-case running time of INSERTION-SORT is

for constant a, b and c

2an bn c

6 7 8( 1) ( 1)

( 1)2 2

n n n nc c c n

)1()1()1()( 5421

nncncncncnT

2 4 5 8( )c c c c

cccnccc

765421

222222)(

Worse – case (Cont.) If input array is in reverse sorted order. Thus tj = j

)1()11(

)1)1)((1()1()1(

nnnnjt

Divide and Conquer Approach

Merge Sort

Quick Sort

Divide-and-Conquer Approach The divide-and-conquer approach involves

three steps at each level of the recursion: Divide the problem into a number of sub-problems

that are similar to the original problem but smaller in size.

Conquer the sub-problems by solving them recursively.

Combine the solution of subproblems into the solution for the original problem.

Merge Sort

The Merge Sort algorithm closely follows the divide-and-conquer approach. It operates as follows, Divide: Divide the n-element sequence to be

sorted into two subsequences of n/2 elements each.

Conquer: Sort the two subsequences recursively using merge sort

Combine: Merge the two sorted subsequences to produce the sorted solution.

Merge Sort (Cont.)

The recursion “bottom out” when the sequence to be sorted has length 1, in which case there is no work to be done, since every sequence of length 1 is already in sorted order.

Merge Sort Example

5 2 4 6 1 3A

0 1 2 3 4 5

DIVIDE&CONQUER

Merge Sort Example (cont.)

1 2 3 4 5 6A

0 1 2 3 4 5

COMBINE

Merge Sort Algorithm

Algorithm MergeSort( A, p, q )Input: A: a sequence of n elements

p: the beginning index of A q: the last index of A

Output: A: a sorted sequence of n elementsif(p < q) then

r = floor((p+q)/2) MergeSort(A,p,r)MergeSort(A,r+1,q)Merge(A,p,r,q)

Algo Merge(A,p,r,q)Input: A, p, r, q : a sorted subsequences A[p…r] and A[r+1…q] Output: A: a sorted sequence A[p…q]

let i=p, k=p, j=r+1while (i ≤ r) and (j ≤ q) if (A[i] ≤ A[j]) then B[k] = A[i]

k++ i++ else

B[k] = A[j] k=k+1j=j+1

if (i>r) then /* If the maximum value of left subsequence is less than the right subsequence */

while(j ≤ q)B[k] = A[j]k++j++

else if(j > q) then /* If the maximum value of left subsequence is gather than the right subsequence */

while(i ≤ r)B[k] = A[i]k++i++

for k = p to qA[k] = b[k]

Merge Sort Analysis

The best case running time is _(n log n)_ The worst case running time is _ O(n log n) _

Quick Sort

Quick Sort, likes merge sort, is based on the divide-and-conquer approach.

To sort an array A[p…r] Divide: Partition (rearrange) the array A[p…r] into

two subarray A[p…q -1] and subarray A[q+1…r] such that: Each element of A[p…q -1] is less than or equal to A[q] Each element of A[q+1…r] is greater than A[q]

Quick Sort (Cont.)

To sort sorting an array A[p…r] (cont.) Conquer: Sort the two subarray A[p…q -1] and

A[q+1…r] by recursive calls to QuickSort. Combine: Since the subarrays are sorted in place, no

work is needed to combine them: the entire array A[p…r] is now sorted.

Quick Sort Example5 2 4 6 1 3A

0 1 2 3 4 5

Quick Sort AlgorithmAlgo QuickSort(A, p, r)

Input: A: A sequence of n numbers p: The first index of A

r: The last index of A

Output: A: A sorted sequence in increasing order of array A

if (p < r) then

q = Partition(A,p,r)

QuickSort(A,p,q-1)

QuickSort(A,q+1,r)

• Rearrange the subarray A[p…r] in place.

• The elements that is less than A[q] are placed at the left side of A[q] and

• The elements that is greater than A[q] are placed at the right side of A[q].

Quick Sort Algorithm (Cont.)Algo Partition(A, p, r)

Input: A: A sequence of n numbers p: The first index of A

r: The last index of AOutput: A: The rearranged subarray A[p…r]

key = A[r]

i = p – 1

for j = p to r -1

if A[ j ] ≤ key then

i = i+1

exchange A[i] and A[j]

exchange A[i+1] and key

return i+1

Quick Sort Analysis

The best case running time is _ (n log n)_ The worst case running time is _ O(n2)_