Foundations II: Data Structures and Algorithms

Transcription

1 Foundations II: Data Structures and Algorithms Instructor : Yusu Wang Topic 1 : Introduction and Asymptotic notation

2 Course Information Course webpage Office hours Tu/Th 9:30 am 11:00 am Grading policy: homework: 20%, two midterms: 40%, final: 40%

3 Exams Midterm 1 Sept. 28 th : 8 10:00pm, Location: JR 251 Midterm 2 Nov. 2 th : 8 10:00pm, Location: JR 251 Final exam: Dec. 11 th (Monday), 12:00pm--1:45pm, Room DL369 Mark you calendar. Contact me within first two full weeks if any schedule conflict for any exam.

4 Notes All homework should be submitted before or in class on the due date. Late homework during the same day receives a 10% penalty. Late homework submitted the next day receives a 30% penalty. You may discuss homework with your classmates. It is very important that you write up your solutions individually, and acknowledge any collaboration / discussion with others.

5 More Information Textbook Introduction to Algorithms Others by Cormen, Leiserson, Rivest and Stein (third edition) CSE 2331 course notes By Dr. Rephael Wenger (SBX) The Art of Computer Programming By Donald Knuth

6 Introduction What is an algorithm? Step by step strategy to solve problems Should terminate Should return correct answer for any input instance

7 This Course Various issues involved in designing good algorithms What do we mean by good? Algorithm analysis, language used to measure performance How to design good algorithms Data structures, algorithm paradigms Fundamental problems Graph traversal, shortest path etc.

8 Asymptotic Notation

9 Sorting problem Input: a 1 Output: permutation of A that is sorted a 2 a n A = <,,. > Example: Input: < 3, 11, 6, 4, 2, 7, 9 > Output: < 2, 3, 4, 6, 7, 9, 11 >

10 Insertion Sort 1 i i+1 n 3, 11, 6, 4, 2, 7, 9 3, 6, 11, 4, 2, 7, 9 3, 4, 6, 11, 2, 7, 9 2, 3, 4, 6, 11, 7, 9

11 Pseudo-code InsertionSort(A, n) for i = 1 to n-1 do key = A[i+1] j = i while j > 0 and A[j] > key do A[j+1] = A[j] j = j - 1 A[j+1] = key

12 Analysis Termination Correctness beginning of for-loop: if A[1.. i] sorted, then end of for-loop: A[1.. i+1] sorted. when i = n-1, A[1.. i+1] is sorted. Efficiency: time/space Depends on input size n Space: roughly n

13 Running Time Depends on input size Depends on particular input Best case Worst case First Idea: Provide upper bound (as a guanrantee) Make it a function of n : T(n)

14 Running Time Worst case T(n) = max time of algorithm on any input of size n Average case T(n) = expected time of algorithm over all possible inputs of size n Need a statistical distribution model for input E.g, uniform distribution

15 Insertion Sort InsertionSort(A, n) for i = 1 to n-1 do key = A[i] j = i while j > 0 and A[j] > key A[j+1] = A[j] j = j - 1 A[j+1] = key do c 1 c 2 n T(n) = Σ ( + i ) = + n + i=2 c 1 c 2 c 3 n 2 c 4 c 5

16 Asymptotic Complexity Why shall we care about constants and lower order terms? Should focus on the relative growth w.r.t. n Especially when n becomes large! E.g: 0.2n 1.5 v.s 500n Second Idea: Ignore all constants and lower order terms Only order of growth --- Asymptotic time complexity

17 Illustration ff nn = OO gg nn

18 Big O Notation f(n) O(g(n)) if and only if c > 0, and n 0, so that 0 f(n) cg(n) for all n n 0 f(n) = O(g(n)) means f(n) O(g(n)) (i.e, at most) We say that g(n) is an asymptotic upper bound for f(n). It also means: lim n f(n) g(n) c E.g, f(n) = O(n 2 ) if there exists c, n 0 > 0 such that f(n) cn 2, for all n n 0.

19 More Examples 5nn 2 + 6nn + 8 = OO nn 3? 100nn nn = OO(nn 2 )? 6nn 3 + 7nn 2 + 3nn = OO(nn 1.5 )? 2 nn = OO nn 2? 3lg nn = OO(nn)? 3 nn = OO 2 nn? 3 nn = OO 2 2nn log 3 nn = OO log 2 nn? nn = OO(nn) lg nn

20 Omega Ω Notation f(n) Ω (g(n)) if and only if c > 0, and n 0, so that 0 cg(n) f(n) for all n n 0 f(n) = Ω (g(n)) means f(n) Ω (g(n)) (i.e, at least) We say g(n) is an asymptotic lower bound of f(n). It also means: lim n f(n) g(n) c

21 Illustration ff nn = Ω gg nn

22 More Examples 5nn 2 + 6nn + 8 = Ω nn 3? 5nn 2 + 6nn + 8 = Ω nn 2? 6nn 3 + 7nn 2 + 3nn = Ω(nn 1.5 )? 2 nn = Ω nn 2? 3lg nn = Ω(nn)? 3 nn = Ω 2 nn? log 3 nn = Ω log 2 nn? 2 log 3 nn = Ω(2 log 2 nn )

23 Theta Θ Notation Combine lower and upper bound Means tight: of the same order ff nn Θ gg nn if and only if cc 1, cc 2 > 0, and nn 0, such that cc 1 gg nn ff nn cc 2 gg nn for any nn nn 0 ff nn = ΘΘ gg nn means ff nn ΘΘ gg nn We say g(n) is an asymptotically tight bound for f(n). It also means: ff(nn) cc 1 lim cc nn gg(nn) 2

24 ff nn = OO(gg nn ) ff nn = Ω(gg nn ) ff nn = Θ(gg nn )

25 Remarks -- 1 ff nn = Θ(gg nn ) if and only if ff nn = OO(gg nn ), and ff nn = Ω gg nn. Insertion sort algorithm as described earlier has time complexity Θ(nn 2 ). Transpose symmetry: If ff nn = OO(gg nn ), if and only if gg nn = Ω ff nn Transitivity: If ff nn = OO(gg nn ) and gg nn = OO(h nn ), then ff nn = OO h nn. Same for Ω and Θ

26 Remarks -- 2 It is convenient to think that Big-O is smaller than or equal to Big-Ω is larger than or equal to Big-Θ is equal However, These relations are modulo constant factor scaling Not every pair of functions have such relations If ff nn OO(gg nn ), this does not imply that ff nn = Ω(gg nn ).

27 Remarks -- 3 Provide a unified language to measure the performance of algorithms Give us intuitive idea how fast we shall expect the alg. Can now compare various algorithms for the same problem Constants hidden! O( n lg lg n ), 2n lg n T(n) = n 2 + O (n) means T(n) = n 2 + h(n), and h(n) = O(n)

28 Pitfalls O(n) + O(n) = O(n) T(n) = n + Σ O(n) k i = 1 = n + O(n) OK? k should not depend on n! It can be an arbitrarily large constant

29 Yet Another Notation Small o notation: f(n) = o(g(n)) means for any cc > 0, nn 0 s.t. for all nn nn 0, 0 ff nn < cccc nn. In other words, Examples: lim = 0 n Is n - lg n = o(n)? Is n = o (n lg n)? f(n) g(n)

30 Yet Another Notation Small ω notation: f(n) = ω(g(n)) means for any cc > 0, nn 0 s.t. for all nn nn 0, 0 cccc nn < ff nn. In other words, lim n f(n) g(n) Examples: = Is n - lg n = ω(n)? Is n = ω(n / lg n)? or lim = 0 n g(n) f(n)

31 Review some basics Chapter 3.2 of CLRS See the board

32 Recall Asymptotic Notation

33 Another View

34 Some Special Cases

35 More Examples nn 3 vs nn nn 3 vs nn 2 nn aa vs. bb nn ln(nn 4 ) vs. log 3 2nn 2lg nn vs. nn lg nn vs. nn εε nn lg nn vs. nn lg nn nn vs. log 2 3 nn nn vs. 2 log 2 nn+4 nn log 2 nn vs. 2 2 log 2 nn

36 More Examples lg nn 2 vs. (lg nn) lg nn vs. ln nn 3 log 2 nn vs. 0.5nn lg 2nn 2 + nn lg nn vs lg (n 3 100n) nn nn lg nn vs. 2nn 2 + nn lg nn In general, we can safely ignore low order terms.

37 Hierarchy

38 More Example Rank the following functions by order of growth: 2 nn 4, nn + 3 lg(3nn 2 4nn), nn nn + 5, nn ln nn, 3 2 nn, 4nn lg nn, nn + lg nn

39 Summary Algorithms are useful Example: sorting problem Insertion sort Asymptotic complexity Focus on the growth of complexity w.r.t input size