1. 1 7.Algorithm Efficiency These factors vary from one machine/compiler (platform) to another  Count the number of times instructions are executed So, measure computing time as T(n)= computing time of an algorithm for input of size n = number of times the instructions are executed Read §7.4 What to measure? Space utilization: amount of memory required  Time efficiency: amount of time required to process the data Depends on many factors: size of input speed of machine quality of source code quality of compiler

2. 2 Example: Calculating the Mean / * Algorithm to find the mean of n real numbers. Receive:integer n  1 and an array x[0],..., x[n–1] of real numbers Return:The mean of x[0],..., x[n–1] ---------------------------------------------------------------------------------------*/ 1. Initialize sum to 0. 2. Initialize index variable i to 0. 3. While i < n do the following: 4.a. Add x[i] to sum. 5.b. Increment i by 1. 6. Calculate and return mean = sum / n. T(n) = 3n + 4 1 1 n+1 n n 1 p. 350

3. 3 Big Oh Notation The computing time of an algorithm on input of size n, T(n), is said to have order of magnitude f(n), written T(n) is O(f(n)) if there is some constant C such that T(n) < C. f(n) for all sufficiently large values of n. Another way of saying this: The complexity of the algorithm is O(f(n)). O(n) Note that constants and multiplicative factors are ignored. Example: For the Mean-Calculation Algorithm: T(n) is f(n) is usually simple: n, n 2, n 3,... 2 n 1, log 2 n n log 2 n log 2 log 2 n Table 7.1, Fig. 7.4 T(n) is also O(n 2 ), O(n 3 ), etc., but use smallest f(n)  most info

4. 4 Worst-case Analysis The arrangement of the input items may affect the computing time. How then to measure performance? best case – not very informative average - too difficult to calculate worst case - usual measure / * Linear search of the list a[0],..., a[n – 1]. Receive:An integer n an array of n elements and item Return:found = true and loc = position of item if the search is successful; otherwise, found is false. */ 1. found = false. 2. loc = 0. 3. While (loc < n && !found ) 4.If item = a[loc] found = true// item found 5. Else Increment loc by 1 // keep searching Worst case: Item not in the list: T L (n) is O(n) Average case (assume equal distribution of values) is

5. 5 Binary Search O(log 2 n) /* Binary search of the list a[0],..., a[n – 1] in which the items are in ascending order. Receive:integer n and an array of n elements and item. Return:found = true and loc = position of item if the search successful otherwise, found is false. */ 1. found = false. 2. first = 0. 3. last = n – 1. 4. While (first <= last && !found ) 5.Calculate loc = (first + last) / 2. 6.If item a[loc] then 9.first = loc + 1.// search last half 10.Else found = true.// item found Worst case: Item not in the list: T B (n) = Makes sense: each pass cuts search space in half! p. 255

6. 6 Recursion A very old idea, with its roots in mathematical induction. It always has:  An anchor (or base or trivial) case  An inductive case So, a function is said to be defined recursively if its definition consists of  An anchor or base case in which the function’s value is defined for one or more values of the parameters  An inductive or recursive step in which the function’s value (or action) for the current parameter values is defined in terms of previously defined function values (or actions) and/or parameter values. Example: Factorials  Base case: 0! = 1  Inductive case: n! = n*(n-1)! Read §7.1, 7.3 Skim §7.2 int Factorial(int n) { if (n == 0) return 1; else return n * Factorial(n - 1); } T(n) =O(n)

7. 7 Computing times of recursive functions Have to solve a recurrence relation. // Towers of Hanoi void Move(int n, char source, char destination, char spare) { if (n <= 1) // anchor (base) case cout << "Move the top disk from " << source << " to " << destination << endl; else { // inductive case Move(n-1, source, spare, destination); Move(1, source, destination, spare); Move(n-1, spare, destination, source); } T(n) = O(2 n ) In emacs/xemacs: Esc-n Esc-x hanoi

8. 8 There are several common applications of recursion where a corresponding iterative solution may not be obvious or easy to develop. Classic examples of such include Towers of Hanoi, path generation, multidimensional searching and backtracking. However, many common textbook examples of recursion are tail-recursive, i.e. the last statement in the recursive function is a recursive invocation. Tail-recursive functions can be written (much) more efficiently using a loop. Comments on Recursion

9. 9 // Counting the number of digits in a positive integer int F(int n, int count) {// recursive, expensive! if (n < 10) return 1 + count; else return F(n/10, ++count); } int F(int n) {// iterative, cheaper int count = 1; while (n >= 10) { count++; n /= 10; } return count; }

10. 10 // Fibonacci numbers int F(unsigned n) {// recursive, expensive! if (n < 3) return 1; else return F(n –1) + F(n - 2); } int F(unsigned n) {// iterative, cheaper int fib1 = 1, fib2 = 1; for (int i = 3; i <= n; i++) { int fib3 = fib1 + fib2; fib1 = fib2; fib2 = fib3; } return fib2; } More complicated recursive functions are sometimes replaced by iterative functions that use a stack to store the recursive calls. (See Section 7.3) Iterative: O(n) Recursive: O(1.7 n )

11. 11 Recursive Examples

12. 12 Recursive Blobs const int maxRow = 15; const int maxCol = 15; typedef char Grid[maxRow][maxCol]; void initGrid(Grid g, int & rows, int & cols); int EatAllBlobs(Grid g, int rows, int cols); void EatOneBlob(Grid g, int x, int y, int rows, int cols); int main() { Grid grid; int rows, cols; initGrid(grid, rows, cols); cout << "\nThere are " << EatAllBlobs(grid, rows, cols) << " blobs in there\n"; }

13. 13 void initGrid(Grid g, int & rows, int & cols) { cout << "# rows, # cols: "; cin >> rows >> cols; cout << "Enter grid of " << rows << " x " << cols << " grid of *'s and.'s:\n"; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) cin >> (g[i][j]); } int EatAllBlobs(Grid g, int rows, int cols) { int count = 0; for (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) if (g[i][j] == '*') { EatOneBlob(g, rows, cols, i, j); count++; } return count; }

14. 14 void EatOneBlob(Grid g, int rows, int cols, int x, int y) { if (x = rows || y >= cols) return; if (g[x][y] != '*') return; // else g[x][y] = '.';// mark as visited EatOneBlob(g, rows, cols, x - 1, y); EatOneBlob(g, rows, cols, x + 1, y); EatOneBlob(g, rows, cols, x, y - 1); EatOneBlob(g, rows, cols, x, y + 1); } # rows, # cols: 3 12 Enter grid of 3 x 12 grid of *'s and.'s:..***.***.......*.*.*... **..***...** There are 3 blobs in there

15. 15

16. 16 Recursive Permutations

17. 17 Recursive Permutations

18. 18 Recursive Permutations

19. 19 Recursive Permutations