CSE 246 Data Structures and Algorithms

1. CSE 246Data Structures and Algorithms Lecture#3

2. How to Compare Formulas? Answer depends on value of N: N 50N2+31N3+24N+15 3N2+N+21+4*3N 1 120 37 2 511 71 3 1374 159 4 2895 397 5 5260 1073 6 8655 3051 7 13266 8923 8 19279 26465 9 26880 79005 10 36255 236527 Quratulain

3. What Happened? N 1 37 12 32.4 2 71 36 50.7 3 159 108 67.9 4 397 324 81.6 5 1073 972 90.6 6 3051 2916 95.6 7 8923 8748 98.0 8 26465 26244 99.2 9 79005 78732 99.7 10 236527 236196 99.9 • One term dominated the sum Quratulain

4. As N Grows, Some Terms Dominate Quratulain

5. Order of Magnitude Analysis Measure speed with respect to the part of the sum that grows quickest Ordering: Quratulain

6. Order of Magnitude Analysis (cont) Furthermore, simply ignore any constants in front of term and simply report general class of the term: grows proportionally to grows proportionally to When comparing algorithms, determine formulas to count operation(s) of interest, then compare dominant terms of formulas Quratulain

7. Analyzing Running Time T(n), or the running time of a particular algorithm on input of size n, is taken to be the number of times the instructions in the algorithm are executed. Pseudo code algorithm illustrates the calculation of the mean (average) of a set of n numbers: 1. n = read input from user 2. sum = 0 3. i = 0 4. while i < n 5. number = read input from user 6. sum = sum + number 7. i = i + 1 8. mean = sum / n The computing time for this algorithm in terms on input size n is: T(n) = 4n + 5. Statement Number of times executed 1 1 2 1 3 1 4 n+1 5 n 6 n 7 n 8 1 Quratulain

8. Big-O Notation • Computer scientists like to categorize algorithms using Big-O notation. • For sufficiently large N, the value of a function is largely determined by its dominant term. • Big-O notation is used to capture the most dominant term in function and to represent the growth rate. • Big-o notation also allows us to establish a relative order among functions by comparing dominant terms • Thus, if running time of an algorithm is O(N2), then ignoring constant , it can be guaranteeing that running time bound to quadratic function. Quratulain

9. Big-O Notation • If you tell a computer scientist that they can choose between two algorithms: • one whose time complexity is O( N ) • Another is O( N2 ), then the O( N ) algorithm will likely be chosen. Let’s find out why… Quratulain

10. Big-O Notation • Let’s consider a function on N, T(N) N is a measure of the size of the problem we try to solve, e.g., Definition: T(N) is O( g(N) ) if: So, if T(N) is O( g(N) ) then T(N) grows no faster than g(N). Example 1 • Suppose, for example, that T is the time taken to run an algorithm to process data in an array of length N. We expect that T will be a function of N • If we now say that T(N) is O(N) we are saying that T(N) grows no faster than N. • This is good news – it tells us that if we double the size of the array, we can expect that the time taken to run the algorithm will double (roughly speaking). Quratulain

11. Example Suppose f(n) = n2 + 3n - 1. We want to show that f(n) = O(n2). f(n) = n2 + 3n - 1 < n2 + 3n (subtraction makes things smaller so drop it) <= n2 + 3n2 (since n <= n2 for all integers n) = 4n2 Therefore, if C = 4, we have shown that f(n) = O(n2). Notice that all we are doing is finding a simple function that is an upper bound on the original function. Because of this, we could also say that This would be a much weaker description, but it is still valid. f(n) = O(n3) since (n3) is an upper bound on n2 Quratulain

12. Question • Suppose you have two algorithms (Algorithm A and Algorithm B) and that both algorithms are O(N). Does this mean that they both take the same amount of time to run? Quratulain

13. Example We will now look at various Java code segments and analyze the time complexity of each: int count = 0; int sum = 0; while( count < N ) { sum += count; System.out.println( sum ); count++; } Total number of constant time statements executed...? Quratulain

14. Example int count = 0; int sum = 0; while( count < N ) { int index = 0; while( index < N ) { sum += index * count; System.out.println( sum ); index++; } count++; } Total number of constant time statements executed ….? Quratulain

15. Example int count = 0; while( count < N ) { int index = 0; while( index < count + 1 ) { sum++; index++; } count++; } Total number of constant time statements executed…? Quratulain

16. Example int count = N; int sum = 0; while( count > 0 ) { sum += count; count = count / 2; } Total number of constant time statements executed…? Quratulain

17. Computer Memory • Every piece of data that is stored in a computer is kept in a memory cell with a specific address. • We can think of these memory cells as being a long row of boxes where each box is labeledwith an address. • Computer memory is linear. • The computer can store many different types of data in its memory. These include basic data types integers, float and characters etc. • Once the computer stores data in the memory cells, it can access the data by using the address of the data cells. Quratulain

18. Computer Memory For example, consider the following instructions for adding two integers together. For example, suppose we want a data structure that can store a group of characters as a word. In many computer languages, this data structure is called a string. If we store the characters for the string 'apple' in the computer's memory Quratulain

19. Computer Memory • But what happens when we try to represent our tree diagram of company XYZ? It doesn't make sense to store the names one after the other because the tree is not linear. • Now we have a problem. We want to represent a nonlinear data structure using computer memory that is linear Quratulain

20. Elementary Data structures • Elementary Data Structure are fundamental approaches to organizing data. These are the building blocks that will be used to implement more complex Abstract Data Types. • Scalar (built-in) data types • Arrays • Linked Lists • Strings Quratulain