3. 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.
3
4. Sorting Concept (Cont.)
Sorting problem
Let 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 ( a1 , a 2 , ..., a n )
Output: A: the reordering ( a1 , a 2 ,..., a n ) of the
input sequence such that
a1 a2 an
4
5. 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.
5
7. 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 = i
for j = i+1 to n
if A[j] < A[min] then
min = j
Swap(A,min,i)
7
8. 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
8
9. 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-1) + (n-2) + (n-3) + … + 2 + 1 = i = n(n-1)/2
i 1
The best case running time is ___ (n2)__
The worst case running time is __ O(n2)__
9
10. 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.
10
11. 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
11
14. 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-1
while i > 0 and A[i] > key
A[i+1] = A[i]
i = i-1
A[i+1] = key
14
16. Insertion Sort Analysis (cont.)
INSERTION-SORT(A) cost times
1. for j = 2 to length(A) c1 n
2. key = A[j] c2 n-1
3. //Insert A[j] into the sorted sequence A[1…j-1] 0 n-1
4. i = j-1 c4 n-1
n
5. while i > 0 and A[i] > key c5 tj
j 2
n
6. A[i+1] = A[i] c6 (t j 1)
j 2
n
7. i = i-1 c7 (t j 1)
j 2
8. A[i+1] = key c8 n-1
16
17. Analysis of Insertion Sort (Cont.)
To Compute the total running time of INSERTION-
SORT, T ( n )
n
T (n) c1 n c2 (n 1) 0(n 1) c4 (n 1) c5 tj
j 2
n n
c6 (t j 1) c7 (t j 1) c8 ( n 1)
j 2 j 2
17
18. Analysis of Insertion Sort (Cont.)
Best – case
If input array is already sorted. Thus tj = 1
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)
an + b for constant a and b
Base-case running time of INSERTION-SORT is (n)
18
19. Analysis of Insertion Sort (Cont.)
Worse – case
If input array is in reverse sorted order. Thus tj = j
n(n 1)
T (n) c1 n c2 (n 1) c4 (n 1) c5 1
2
(n 1) n (n 1) n
c6 c7 c8 ( n 1)
2 2
c5 c6 c6 2 c5 c6 c7
T (n) n c1 c2 c4 c8 n
2 2 2 2 2 2
(c2 c4 c5 c8 ) an
2
bn c
for constant a, b and c
2
Worse-case running time of INSERTION-SORT is (n )
19
20. Analysis of Insertion Sort (Cont.)
Worse – case (Cont.)
If input array is in reverse sorted order. Thus tj = j
n
n n n(n 1)
n(n 1) j
tj j 1 j 1
2
j 2 j 2 2
n n
(n 1)(( n 1) 1) (n 1) n
(t j 1) (j 1) (1 1)
j 2 j 2 2 2
20
22. 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.
22
23. 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.
23
24. 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.
24
27. 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 elements
if(p < q) then
r = floor((p+q)/2)
MergeSort(A,p,r)
MergeSort(A,r+1,q)
Merge(A,p,r,q)
27
28. 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+1
while (i ≤ r) and (j ≤ q)
if (A[i] ≤ A[j]) then
B[k] = A[i]
k++
i++
else
B[k] = A[j]
k=k+1
j=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 q
A[k] = b[k]
28
29. Merge Sort Analysis
The best case running time is _ (n log n)_
The worst case running time is _ O(n log n) _
29
30. 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]
30
31. 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.
31
33. Quick Sort Algorithm
Algo 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
• Rearrange the subarray
if (p < r) then A[p…r] in place.
• The elements that is less
q = Partition(A,p,r) than A[q] are placed at the
left side of A[q] and
QuickSort(A,p,q-1) • The elements that is
greater than A[q] are placed
QuickSort(A,q+1,r) at the right side of A[q].
33
34. 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 A
Output: 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 34
35. Quick Sort Analysis
The best case running time is _ (n log n)_
The worst case running time is _ O(n2)_
35
