MPATE-GE 2618: C Programming for Music Technology. Unit 4.2

Transcription

1 MPATE-GE 2618: C Programming for Music Technology Unit 4.2

2 Quiz 1 results (out of 25) Mean: 20.89, (standard deviation = 2.68) Equivalent to 83 % (SD = 10.7) Median: 21.5 Highest score: 25 Lowest score: 15

3 Pointers Syntax To declare a pointer int *ptr; To get the value stored at the address contained in a pointer value = *ptr; To change the value of the variable referenced by a pointer *ptr = value; To take the address of a variable ptr = &var_name; Warning: Declaring a pointer does not allocate the space to which it points. For example: int *foop; declares a pointer to an integer, but does not allocate space for the integer. If you assign something to *foop, you will either crash your program or get garbage.

4 Pointers and changing values in functions Recall that you can t change values of arguments passed to functions except in the case of arrays. Let s say we wanted to write a function divide that performed integer division and returned both the result and the remainder. Functions can only return a single value, but we have two values to return. In order to return two values, we might have used globals. Using globals to return values from functions is normally considered bad style. Another problem is that if we return a value, there s no mechanism for reporting an error (divide by 0). A better solution uses pointers. See divide.c

5 Functions and reference parameters If you are calculating just one value, a function that returns a value is generally easier to use than a function that uses a reference (i.e. use a pointer to a value). If you are calculating more than one quantity, generally it is best to use a reference parameter for each and not to return one as a function value.

6 structs and pointers When using a pointer to reference a member of a struct, use the -> operator instead of. E.g. typedef struct Point { int x; int y; } Point; Point p; Point *pptr = &p; pptr->x = 3; // equivalent to p.x = 3; pptr->y = 4; // equivalent to p.y = 4;

7 Give me a few Pointers

8 Efficiency So far we haven t given much thought to how efficiently our programs ran. Sometimes it s OK to worry only about getting a program correct and not worry about making it efficient (fast). Usually, you want to at least think about what inefficiencies there might be in a program. In your assignments, you should begin thinking about how efficient your algorithms are.

9 Example: Searching Say we re trying to find the location of a value in an array of 10 unsorted numbers. On average, approximately how many comparisons will you have to make before you find it? What is the greatest number of comparisons you could possibly make? Let s generalize now: say we re trying to find a value in an array of n numbers. On average, approximately how many comparisons will you have to make to find the location? What is the greatest number of comparisons you could possibly make? When we express the efficiency of an algorithm, we can think about both the average running time and also the worst case running time. We normally express the problem size in terms of the number of elements (n)in the problem (in this case, the number of values in an array). We then express the efficiency as a function of n. In this problem, the expected search time is what?

10 Algorithmic efficiency It is often easier to compute worst-case performance (compared to expected performance). In sorting, we often use the number of comparisons as a measure of the efficiency (sometimes called complexity). We use a system called big-o notation to express an algorithm s efficiency.

11 Definition of Big-O Assume that an algorithm solves a problem of size n, in c * n 2 operations for some constant c, then the time complexity of that algorithm is said to be O(n 2 ) (pronounced order n-squared). More formally: a function g(n) is said to be O(f(n)) if there exists a constant c such that g(n) <= c * f(n) for all but some finite set of non-negative values for n. Intuitively, an algorithm that is O(f(n)) runs in a time that is proportional to f(n).

12 Big-O and efficiency Going back to our algorithm to search for a number, both the expected time (n/2) and the worst time (n) are O(n) since n/2 can be expressed as (1/2) * n. In our formula above, f(n) = n and c = ½. Which algorithm is more efficient? An algorithm that runs in 6n steps or 2n 2 steps? What is the big-o notation for the algorithms in the last question? Your friend is trying to sort some data and has two algorithms. He runs the algorithms on two sets of data, one with 10 elements and another with 10,000 elements. On the first (smaller) set, algorithm #1 is faster. On the second set (larger), algorithm #2 is faster. He is very confused. Can you explain how this might be the case?

13 In general An algorithm requiring constant time not dependent on the number of elements is O(1). An array lookup is an O(1) procedure. An O(log n) or logarithmic algorithm commonly uses a divide-and-conquer type approach. Binary search is a good example. An algorithm you can do with a single for-loop is usually O(n). Many examples of this: e.g. initializing an array, scanning an array for an element. An O(n log n) algorithm, also known as linearithmic or loglinear, solves a problem by breaking it up into smaller sub-problems, solving them independently, and then combining solutions. Better sorting algorithms have this sort of complexity. Computing an FFT is also in this category. An algorithm requiring a doubly-nested for-loop is usually O(n 2 ). Practical for use only on relatively small problems. An algorithm requiring a triply-nested for-loop is usually O(n 3 ). O(c n ) or exponential algorithms are not practical, arising naturally in brute-force solution to problems where you try every possibility until you get the solution. Example: looking ahead in chess by considering all possible moves.

14 Sorting We re going to embark upon a survey of different sorting techniques now. Some important things to focus on: The method The data structure used Efficiency of the algorithm (worst case and expected running times) Advantages/disadvantages of one algorithm over another What makes the sort go to worst case running time

15 Running times

16 Selection sort N.B. this algorithm is implemented for you in helper.c in Problem Set 3. The basic algorithm: 1. Find the smallest element, put it at the beginning of the array. 2. Find the next smallest element, put it in the next slot. 3. Continue until all the entries are sorted Original position After first step After second step After next step After next step

17 Selection Sort analysis What is the worst case running time of this algorithm? There would be n swaps. 2 More importantly there are approx. n compares. So the running time is O(n 2 ). 2 What is the expected case running time? The same as above, O(n 2 ).

18 Bubble sort Selection sort uses the observation that you can sort a list of elements by repeatedly finding the smallest element. Another possible observation: If you look at any two adjacent items in the array, the first one will be smaller than the second one if the list is sorted. If you examined every pair of two elements and guaranteed that this was true, the list would be sorted. How can we turn this into an algorithm for sorting? while the list is not sorted examine each pair of two adjacent elements if the first element is greater than the second, swap them. How will we know when the list is sorted?

19 Bubble sort, continued Here s our C code: void bubblesort(int array[], int numitems) { int i, nswaps; do { nswaps = 0; /* We will loop through the array comparing each pair * of items. Since we will always look ahead one (we * will compare the current element to the next element) * we want to stop our loop one earlier than we normally * would to loop through an array. */ for (i = 0; i < numitems 1; i++) { if (array[i] > array[i + 1]) { swapelements(array, i, i + 1); nswaps++; } } } while (nswaps!= 0); }

20 Bubble sort, step by step Original position Make comparison (do swap) After first swap second compare (no swap) third compare (no swap) fourth compare (do swap) After second swap End of first pass through list nswap!= 0; keep looping first compare (no swap) second compare (no swap) third compare (do swap) After swap fourth compare (no swap) End of second pass through list nswap!= 0; keep looping first compare (no swap) second compare (no swap) third compare (no swap) fourth compare (no swap) End of first pass through list nswap == 0; done

21 Bubble sort analysis Average running time is O(n 2 ). Large elements at the beginning of the list do not pose a problem, as they are quickly swapped. Small elements towards the end, however, move to the beginning extremely slowly. In general, bubble sort is highly inefficient, even among the O(n 2 ) algorithms like selection sort and insertion sort.

22 Binary search: recursive pseudocode On input array, first, last, and k, define recurse as: If first > last then return false. Let middle = (first + last) / 2. Else if k < array[middle] then return recurse(array, first, middle 1, k). Else if k > array[middle] then return recurse(array, middle + 1, last, k). Else return true. Running time: log 2 n