 # CS16: Data Structures & Algorithms | Spring 2014 Midterm Review 3/16/15 2015.

## Presentation on theme: "CS16: Data Structures & Algorithms | Spring 2014 Midterm Review 3/16/15 2015."— Presentation transcript:

CS16: Data Structures & Algorithms | Spring 2014 Midterm Review 3/16/15 2015

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree  binary search (BS), rand select (median), seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op “counting”  Loops, recursion  Recurrence relations  Inductive proofs  O(), Ω(), Θ()  Worst case, average case, expected case  Master theorem

Selection Pseudocode select(list, k): pivot = list[rand(0, list.size)] L = [] E = [] G = [] for x in list: if x < pivot: L.append(x) if x == pivot: E.append(x) if x > pivot: G.append(x) if k < L.size: return select(L, k) else if k < (L.size + E.size) return pivot else return select(G, k – (L.size + E.size)) Tuesday, March 3, 2015 3

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree  binary search (BS), rand select (median), seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op “counting”  Loops, recursion  Recurrence relations  Inductive proofs  O(), Θ(), Ω()  Worst case, average case, expected case  Master theorem

mergesort(list) 1 def mergesort(list): 2 """mergesort: list -> list 3 Consumes: a list of numbers, list 4 Produces: a sorted list of numbers 5 """ 6 if (len(list) == 1): 7 return list 8 m = len(list)/2 9 L1 = mergesort(list[:m]) 10 L2 = mergesort(list[m:]) 11 return merge(L1, L2)

mergesort(list) 1 def mergesort(list): 2 """mergesort: list -> list 3 Consumes: a list of numbers, list 4 Produces: a sorted list of numbers 5 """ 6 if (len(list) == 1): 7 return list 8 m = len(list)/2c3 9 L1 = mergesort(list[:m])T(n/2) 10 L2 = mergesort(list[m:])T(n/2) 11 return merge(L1, L2)c5 n + c6

 T(1) = c3 (base case)  T(n) = c4 + T(n/2) + T(n/2) + c5*n + c6  T(n) = 2 T(n/2) + c5 n + c1  (c1 = c6 + c4)

merge(L1, L2) 1 def merge(L1, L2): 2 """merge: list, list -> list 3 Consumes: two sorted lists of numbers, L1 and L2 4 Produces: a single merged sorted list of numbers 5 """ 6 i1 = 0 # index into L1 7 i2 = 0 # index into L2 8 out = zeros(len(L1)+len(L2)) 9 while (i1 < len(L1) or i2 < len(L2)) : 10 if (i2 == len(L2) or (i1 < len(L1) and L1[i1] < L2[i2])): 11 out[i1+i2] = L1[i1] 12 i1 = i1 + 1 13 else: 14 out[i1+i2] = L2[i2] 15 i2 = i2 + 1 16 return out

First 3 lines: c6 While: n*c5 n*c5 + c6 for merge

Have recurrence relation, now plug-and-chug T(1) = c3 T(n) = 2 T(n/2) + n*c5 + c1 T(1) = c3 T(2) = 2*T(1) + 2 c5 + c1 = 2 c3 + 2c5 + c1 T(4) = 2*(2*c3 + 2c5 + c1) + 4c5 + c1 = 4c3 + 4c5 + 2c1 + 4c5 + c1 = 4 c3 + 8c5 + 3c1 T(8) = 2*(4 c3 + 8c5 + 3c1) + 8c5 + c1 = 8c3 + 16c5 + 6c1 + 8c5 + c1 = 8 c3 + 24c5 + 7c1 T(n) = n c3 + ? c5 + (n-1) c1 ? = (0,2,8,24) n log n = (0, 2, 8, 24) T(n) = n c3 + (n log n) c5 + (n-1) c1

Prove T(n) = c5 n log n + c3 n + c1 (n-1)  T(1) = c3 // def’n base case  T(k) = c5 k log k + c3 k + c1 (k-1) // inductive assump.  T(2k) = 2T(k) + c5 2k + c1 // def’n rec. rel.  = 2 (c5 k log k + c3 k + c1(k-1)) + c5 2k + c1  = 2 c5 k log k + 2 c3 k + 2 c1(k-1) + c5 2k + c1  = c5 2k (log k + 1) + 2k c3 + c1 (2k-2+1)  = c5 2k (log k + log 2) + 2k c3 + c1(2k-1)  = c5 2k log 2k + c3 2k + c1(2k-1) Shown for n=1; shown if true for n=k, also true for n= 2k Therefore, true for all n positive powers of 2 

Master Theorem Let T(n) be a monotonically increasing function that satisfies: T(n) = aT(n/b) + Θ (n d ) Where a≥1, b>1, d≥0. T(n) is Θ (n d ) if a < b d T(n) is Θ (n d log n)if a = b d T(n) is Θ (n log a )if a > b d MS: T(n) = 2 T(n/2) + c5 n + c1 a b d=1 b a is number of sub-problems 1/b is size of sub-problems n d is cost within a given level

Amortized Analysis

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree, graph, directed graph, directed acyclic graph  binary search (BS), rand select (median), topological sort, convex hull, seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op counting  Loops, recursion  Recurrence relations  Inductive proofs  O(), Θ(), Ω()  Worst case, average case, expected case  Master theorem

Recurrence Relations? T(n) = 3n 3 + n log n T(n) = 2 n! T(n) = n + 2 T(n-1) T(n) = 3n 2 + n + T(n/3)

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree, graph, directed graph, directed acyclic graph  binary search (BS), rand select (median), topological sort, convex hull, seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op counting  Loops, recursion  Recurrence relations  Inductive proofs  O(), Θ(), Ω()  Worst case, average case, expected case  Master theorem

Master Theorem Let T(n) be a monotonically increasing function that satisfies: T(n) = aT(n/b) + Θ (n d ) Where a≥1, b>1, d≥0. T(n) is Θ (n d ) if a < b d T(n) is Θ (n d log n)if a = b d T(n) is Θ (n log a )if a > b d What is O() of T(n) = n + T(n-2), T(2)=2 (n even) b a is number of sub-problems 1/b is size of sub-problems n d is cost within a given level

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree, graph, directed graph, directed acyclic graph  binary search (BS), rand select (median), topological sort, convex hull, seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op counting  Loops, recursion  Recurrence relations  Inductive proofs  O(), Θ(), Ω()  Worst case, average case, expected case  Master theorem

Binary Tree  A set of nodes that are connected with directed connections from parents to children so that each node has one parent, each parent has 0, 1, or 2 children, there are no cycles, and all nodes are directly or indirectly parented by a single root node.  Data structure that has 0, 1, or 2 children that are binary trees.

Ok in pseudocode? merge(L1,L2): merge L1 and L2 return result insertionSort(L) insert elements into L2 return L2 qsort(L): pick random pivot. selectionSort(L): while (len(L) > 0): find and nuke min in L append min to L2 return L2

Structures/Algorithms Analysis  list, array, queue, stack, priority queue, heap, hash table, binary search tree, tree, graph, directed graph, directed acyclic graph  binary search (BS), rand select (median), topological sort, convex hull, seamcarve  quicksort (QS), mergesort (MS), heapsort, insertion sort, selection sort, radix sort  Op counting  Loops, recursion  Recurrence relations  Inductive proofs  O(), Ω(), Θ()  Worst case, average case, expected case  Master theorem

Quicksort(list)  Pick random pivot, v  Construct 3 lists, SL, SV, SR  Quicksort(SL)  Quicksort(SR)  Return(SL,SV,SR)append now-sorted lists

quicksort(list) 1 def quicksort(list): 2 """quicksort: list -> list 3 Consumes: list of numbers 4 Produces: sorted list 5 """ 6 if(len(list)==1 or len(list)==0): 7 return list 8 pivot = random.choice(list) 9 small = [] 10 npivot = 0 11 big = [] 1 for e in list: 2 if (e < pivot): 3 small.append(e) 4 else: 5 if (e > pivot): 6 big.append(e) 7 else: 8 npivot = npivot + 1 9 small = quicksort(small) 10 big = quicksort(big) 11 while (npivot): 12 small.append(pivot) 13 npivot = npivot - 1 14 return small + big

dqsort(list) 1 def dqsort(list): 2 # dqsort: list -> list 3 # Consumes: a list of numbers, list 4 # Produces: a sorted list of numbers 5 if (len(list) == 1): 6 return list 7 m = len(list)/2 8 p = randSelect(m, list) 9 for e in list: 10 if (e<p) add e to L1 11 else add e to L2 12 L1 = dqsort(L1) 13 L2 = dqsort(L2) 14 return (L1 + L2)# concat

HullSort(L) Reduction!  Create list of points, M = {(L i, (L i ) 2 )}  H = ConvexHull(M)  Return list of first coordinates of H i  (start at smallest one)

Induction  Prove 2n > n for all positive integers  Base case  n=1, 2 > 1  Inductive step: if true for n=k, true for n=k+1  assume 2k > k  Add 2 to the left side and 1 to the right side, preserving the inequality  2k + 2 > k + 1  2(k+1) > (k+1)  True for all n

Similar presentations