Algorithms & Complexity

Frank Kair

Transcript

1. Algorithms & Complexity Frank Kair
2. Last time...
3. Project Euler
4. polyglot-euler
5. polyglot-euler
6. polyglot-euler
7. Fibonacci example
8. Analysis of Algorithms Asymptotics / Complexity Theory
10. Applied Maths → Computer Science
11. Complexity Analysis We need a way to define the runtime of an algorithm regardless of the machine it’s currently running on.
12. Linear Search
13. Binary Search
14. Big O Big O is a mathematical notation that describes the limiting behaviour of a function when the argument tends towards a particular value or infinity.
15. The letter O is used because the growth rate of a function is also referred to as the order of the function. [...] an upper bound on the growth rate of the function. Big O
16. Big O
17. Big O Length Iteration worst case 1 1 10 10 100 100 1000 1000 10000 10000 … ...
18. Big O
20. Big O
21. How do we profile these algorithms?
22. Just count the loops, then?
23. Merge Sort
24. Merge Sort
25. Merge Sort
26. Merge Sort O(n)
27. Merge Sort
28. Merge Sort O(n)
29. Merge Sort O(n) O(n)
30. Merge Sort O(n) O(n) ?
31. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n
32. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = 2T(n/2) + n
33. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = 2T(n/2) + n = 2 [ 2T(n/4) + n/2 ] + n
34. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = 2T(n/2) + n = 2 [ 2T(n/4) + n/2 ] + n = 4T(n/4) + 2n = 4 [ 2T(n/8) n/4 ] + n = 8T(n/8) + 3n = 16T(n/16) + 4n = ... = (2^k)T(n/(2^k)) + kn
35. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn T(1) = c Merge Sort
36. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn T(1) = c n/(2^k) = 1 Merge Sort
37. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn T(1) = c n/(2^k) = 1 2^k = n Merge Sort
38. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn T(1) = c n/(2^k) = 1 2^k = n k = lg n Merge Sort
39. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn k = lg n T(n) = Merge Sort
40. Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn k = lg n T(n) = (2^lg n)T(1) + n lg n Merge Sort
41. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn k = lg n T(n) = (2^lg n)T(1) + n lg n = cn + n lg n
42. Merge Sort Recurrence relation T(n) = c if n == 1 = 2T(n/2) + n T(n) = (2^k)T(n/(2^k)) + kn k = lg n T(n) = (2^lg n)T(1) + n lg n = cn + n lg n O(n log n)
43. Does it matter?
44. Data Structures
45. Arrays vs Linked Lists
46. Binary Search Tree
47. B+ Trees
48. Back to Fibonacci… Why was it bad?
49. Fibonacci
50. Fibonacci
51. Fibonacci
52. Fibonacci
53. Fast Fibonacci
54. Paradigms / Techniques
55. Divide and Conquer Dynamic Programming Greedy Paradigms / Techniques
56. The Classics
57. Fast Fourier Transform Page Rank Dijkstra Miller-Rabin The Classics
58. Thank you!