1. Eitan Netzer Tutorial 4-5
Sorting
Eitan Netzer
Tutorial 4-5

2. Insertion sort

3. Pseudocode * O(n2), In space sort!
for i ← 1 to length(A) j ← i while j > 0 and A[j-1] > A[j] swap A[j] and A[j-1] j ← j - 1
* O(n2), In space sort!

4. Merge sort

5. Simulation

7. Pseudocode

9. Time complexity
T(n) = 2T(n/2)+1
master therom

10. Heap sort
In Place Sort
Binary heap is an array which is a binary tree every node is bigger then is childs
simulation link:

12. Heapify
Inforce Heap properties

13. Build Heap O(nlg(n)) Is it the best bound? Height of heap: floor(logn)
number of nodes at height h: ceil(n/2h+1)
h=0 buttom of tree
h= lgn root

14. Build Heap time analysis
Height of heap:
floor(logn)
number of nodes at height h: ceil(n/2h+1)
h=0 buttom of tree
h= lgn root
tip add Series formulas page

15. Heap sort

17. Quicksort The steps are:
Pick an element, called a pivot, from the array.
Reorder the array so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partitionoperation.
Recursively apply the above steps to the sub-array of elements with smaller values and separately to the sub-array of elements with greater values.
In place sort
Average case analysis Θ(nlgn), Worst case analysis Θ(n2)

21. Pseudocode
// left is the index of the leftmost element of the subarray // right is the index of the rightmost element of the subarray (inclusive) // number of elements in subarray = right-left+1 partition(array, left, right) pivotIndex := choosePivot(array, left, right) pivotValue := array[pivotIndex] swap array[pivotIndex] and array[right] storeIndex := left for i from left to right if array[i] < pivotValue swap array[i] and array[storeIndex] storeIndex := storeIndex swap array[storeIndex] and array[right] // Move pivot to its final place return storeIndex
quicksort(A, i, k): if i < k: p := partition(A, i, k) quicksort(A, i, p - 1) quicksort(A, p + 1, k)

22. Question
How can we change quicksort to return the m smallest values (sorted)
analyis time complexity

23. Solution
quicksort(A, i, k,m): if i <= m: p := partition(A, i, k,m) quicksort(A, i, p - 1,m) quicksort(A, p + 1, k,m)
first partition run O(n)
then O(mlgm)
worst case O(nm)

24. Linear time sorting

25. Counting Sort Assuming numbers belong to a closet set of a finite size
such as 1,2,3,...,k
not in place
stable - first to appear

26. In a nutshell create a vector histogram of the array
“integral” (cumsum) the histogram
use the cumsum vector to find elements locations

27. Pseudocode

30. Radix sort Asumming number of digit is known (d)
Sort by least significant digit up to most significant digit
O(nd)
when is radix sort stable?

31. msd
lsd
start

32. Bucket sort
Assuming uniform distribution

34. Pseudocode