foundations of data structures practical session #11 sort properties, quicksort algorithm
TRANSCRIPT
2
Sorting- problem definition
A sorting algorithm is an algorithm that puts elements of a list in a certain order.
Since the dawn of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement.
3
Sorting- algorithms properties
• Running time (worst/average/best cases).• Additional memory required.• “In place” algorithms require additional
memory.• Stability- stable sorting algorithms maintain
the relative order of records with equal keys.
4
Comparison sorting
A comparison sort is a type of sorting algorithm that only reads the list of elements through a single abstract comparison operation (i.e., ) that determines which of two elements should occur first in the final sorted list.• Simple algorithms. For example: insertion sort, selection
sort, bubble sort - .• Recursive algorithms. For example: merge sort, quicksort - .• Comparison sort algorithms have a lower bound
of comparison operations. This is a consequence of the limited information available through comparisons alone.
5
Quicksort
quickSort(A)quickSort(A, 0, A.length)
quickSort(A, low, high)if (high > low){
pivot partition(A, low, high)quickSort(A, low, pivot-1)quickSort(A, pivot+1, high)
}
Quicksort cont’d
partition routine chooses a pivot, partitions the array around it and returns its index.
6
4 17 21 12 3 9 1 15 615 17 21 12 3 9 1 4 6
low
pivot
highleft rightleft
Swap!
left left rightrightrightright
15 17 21 12 9 3 1 4 6
rightleft
15 17 21 12 9 6 1 4 3
pivot
7
Quicksort cont’dint partition( A, low, high )
pivot_item A[low]left low, right high, pivot leftwhile ( left < right ) {
while (left < high && A[left] ≤ pivot_item) // Scan right left++
while (A[right] > pivot_item) // Scan leftright--
if (left < right) swap(A, left, right) } // Right is the final position of the pivot
swap(A, pivot, right)return right
8
Quicksort cont’d
Run-time complexity analysis• Partition on each step costs .• Best case scenario- chosen pivot is a median
(or close). Then , and the solution is .• Worst case scenario- pivot is the min/max
key. Then , and the solution is .
9
Question 1
Given a set of elements and an index (), suggest an expected time algorithm for finding the -smallest element.
Example: For the following set of numbers: {6, 3, 2, 4, 1, 1, 2, 6} The 4-smallest element is 2.
10
Question 1 cont’dThe solution is based on quicksort algorithm.
Select(k, S) { // Returns k-th element in S.pick x in Spartition S into L, E, G such that:max(L) < x, E = {x}, x < min(G)if k ≤ length(L) // Searching for item ≤ xreturn Select(k, L)else if k ≤ length(L) + length(E) // Foundreturn xelse // Searching for item ≥ xreturn Select(k - length(L) - length(E), G)
11
Question 1 cont’d
In the worst case: the chosen pivot, , is the maximal (or minimal) element in the current array. Therefore .
In the mean case: similar to quick-sort, the pivot is a good approximation of a median.Therefore, (master theorem, case 3).
12
Question 2
Given an array of numbers, suggest an expected time algorithm to determine whether there is a number in that appears more than times.
13
Question 2 cont’dIf appears more than times in , then is the -smallest in .
Frequent (A, n) x ← Select(, A) // find middle element count ← 0
// count appearances of the middle elementfor i ← 1 to n do if (A[i] = x) count ++if count > n/2 return TRUEelse return FALSE
Time Complexity: In the mean case, Select algorithm runs in , computing count takes as well. Total run time in the mean case is .
14
Question 2 cont’d
An alternative solution is using a hash table that maps an element (key) to its number of appearances (value).• Calculate a histogram of elements of A, store
it in the hash map.• Traverse the entries of the hash to find an
entry whose value is greater than • Average running time is .
15
Question 3
records are stored in an array of size .Suggest an algorithm to sort the records in (time) and no additional space, in each of the following cases:
I. All the keys are either 0 or 1.
Solution: Use the partition method (Quick-Sort) with pivot 0. Time complexity is .
16
Question 3 cont’d
II. All the keys are in the range , is constant.
Solution: First, partition with pivot 1, this way all the records with key 1 will be on the first indices of the array.Second, partition with pivot 2...After steps is sorted.Time complexity is the cost of partitions, i.e. .
17
Question 4
Given the following algorithm to sort an array A of size n, argue its correctness and find its recurrence formula.
newSort(A)if |A| = 2
if A[0] > A[1] swap(A, 0, 1)
retutn Aelse
newSort(A[1..2n/3]) // Sort recursively the first 2/3 of AnewSort(A[n/3+1..n]) // Sort recursively the last 2/3 of AnewSort(A[1..2n/3])) // Sort recursively the first 2/3 of A