# Sorting Insertion sort Pseudocode Merge sort

```Insertion sort
Sorting
Eitan Netzer
Tutorial 4-5
Pseudocode
for i ← 1 to length(A)
j←i
while j &gt; 0 and A[j-1] &gt; A[j]
swap A[j] and A[j-1]
j←j-1
* O(n2), In space sort!
Merge sort
Simulation
Pseudocode
Time complexity
Heap sort
T(n) = 2T(n/2)+n
In Place Sort
master therom
Binary heap is an array which is a binary tree
every node is bigger then is childs
https://www.cs.usfca.
edu/~galles/visualization/HeapSort.html
Heapify
Inforce Heap properties
Build Heap
Build Heap time analysis
O(nlg(n))
Is it the best bound?
Height of heap:
floor(logn)
Height of heap:
floor(logn)
number of nodes at height h: ceil
(n/2h+1)
number of nodes at height h: ceil
(n/2h+1)
h=0 buttom of tree
h= lgn root
h=0 buttom of tree
h= lgn root
Heap sort
Quicksort
The steps are:
1. Pick an element, called a pivot, from the array.
2. 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.
3. 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
quicksort(A, i, k):
if i &lt; k:
p := partition(A, i, k)
quicksort(A, i, p - 1)
quicksort(A, p + 1, k)
// 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
Question
How can we change quicksort to return the m smallest
values (sorted)
partition(array, left, right)
pivotIndex := choosePivot(array, left, right)
pivotValue := array[pivotIndex]
analyis time complexity
swap array[pivotIndex] and array[right]
storeIndex := left
for i from left to right - 1
if array[i] &lt; pivotValue
swap array[i] and array[storeIndex]
storeIndex := storeIndex + 1
swap array[storeIndex] and array[right] // Move pivot to its final place
return storeIndex
Solution
quicksort(A, i, k,m):
if i &lt;= 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
In a nutshell
Assuming numbers belong to a closet set of a finite size
such as 1,2,3,...,k
create a vector histogram of the array
“integral” (cumsum) the histogram
not in place
use the cumsum vector to find elements locations
stable - first to appear
Pseudocode