1. Computability Start complexity. Motivation by thinking about sorting. Homework: Finish examples.

2. Introduction Say you have a way to compute a problem –There exists a TM decider. But how effective / efficient / good is the algorithm? –maybe it takes a really long time…. –maybe it takes a lot of space… –Other measures to be explored later.

3. Introduction, cont. Challenge is to measure the time or the space or some other resource to solve problems –To use a particular approach/algorithm to solving problems Usual procedure is to produce the answer as an expression in terms of the size of the problem and Put the answer as a limit… What happens as the problem gets bigger?

4. Note It is possible to talk about complexity for a problem that doesn't have a size, but generally it is done for problems such as –sorting –searching –finding best X … such as shortest route for a traveling salesman –encoding and decoding codes –encoding and decoding images –others

5. Time measures Sometimes restrict / focus on just one operation –compares for sorts or searches Upper bounds (will give formal definition) Total maximum number of steps. Worst case Average case: average over all inputs.

6. Sorting How would you sort a list of N numbers, ending up with lowest to highest?

7. Ways of evaluating sorts Time taken (sometimes just focus on compares and swaps) Space stable or not: if two values in the set are equal, and one before the other, after the sort, they will remain the first before the second –This is important for sorting records on multiple keys adaptive: takes less time if list already nearly in order

8. Bubble sort idea Start at beginning. Compare value to its neighbor. If >, swap. Go on to next position. Keep going to the end. This is one pass –Effect of first pass is to bring highest value to the top. Do passes. Don't have to go to the end—can stop earlier and earlier. Only do another pass if a swap took place. Values bubble up.

9. Bubble sort for (e = n;e>1;e--) { swapped = false; for (j = 1;j<=(e-1);j++) if (a[j] < a[j+1]) { swap (j,j+1) ; //separate function swapped = true ;} // invariant: a[1..i] in final position if (!swapped) break; }

10. Bubble sort Could take up to n * (n-1) comparisons. This will be termed O(n 2 ) when we get to defining it. Takes only a small amount of extra space: and this is not dependent on size of data. stable adaptive

11. Merge idea Pass –divide array in half –sort each half –combine two parts in order Combining two sorted sets is easier (quicker) than sorting a set. Recursive Claim: combine easier (smaller) sorting tasks with the easier merging task makes for a quicker algorithm. –Note: every item is not compared with every other item.

12. Conditional operator Recall 3 operand operator x = (condition) ? y : z; if (condition) then y else z Recall j++ returns the current value of j and THEN increments j. In merge, to merge two sorted parts: a[k++] = (a[j] < b[i]) ? a[j++] : b[i++]; This decides which is less, if it is the j th element in a, assigns it to be the next and increments j. Otherwise, assigns the i th element from b and increments i.

13. Merge sort //a is an array, sort(a, 1, m) sorts the array 1 through m // split in half m = n / 2; // recursive sorts sort (a,1,m); sort (a,m+1,n); // merge sorted sub-arrays using temp array b = copy (a,1,m); i = 1; j = m+1; k = 1; while(( i <= m) &&( j <= n)) { a[k++] = (a[j] < b[i]) ? a[j++] : b[i++]; } // invariant: a[1..k] in final position while (i <= m) { //any leftovers in first part a[k++] = b[i++] } // invariant: a[1..k] in final position

14. Merge sort Does fewer compares, bounded by n*ln(n). –The merge operation is more efficient. –Not comparing everything to everything else. Requires extra space: bounded by n. stable NOT adaptive: always does the same thing even if original list sorted.

15. There is a difference! Visualization: http://www.sorting-algorithms.com/

16. Other sorts insertion heap quicksort ?

17. Homework Preparation for next time Examine other sorts. Report back.