Eitan Netzer Tutorial 4-5 Sorting Eitan Netzer Tutorial 4-5

Insertion sort

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!

Merge sort

Simulation

Pseudocode

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

Heap sort In Place Sort Binary heap is an array which is a binary tree every node is bigger then is childs simulation link: https://www.cs.usfca.edu/~galles/visualization/HeapSort.html

Heapify Inforce Heap properties

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

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

Heap sort

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)

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 - 1 if array[i] < pivotValue swap array[i] and array[storeIndex] storeIndex := storeIndex + 1 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)

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

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)

Linear time sorting

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

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

Pseudocode

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?

msd lsd start

Bucket sort Assuming uniform distribution

Pseudocode