1. קורס תכנות שיעור עשירי: מיונים, חיפושים, וקצת סיבוכיות חישוב

2. משתנים, מצביעים וכתובות משתנה מוגדר ע"י type name משתנה מצביע מוגדר ע"י type * name & - אופרטור שמחזיר כתובת של משתנה * - אופרטור שמקבל מצביע מחזיר הערך

3. מערכים ומצביעים מצביע מכיל כתובת, שם המערך הוא כתובת ניתן לבצע השמה בין המערך ומצביע לאחר ההשמה ניתן להשתמש במצביע כאילו היה שם המערך ניתן להשתמש במערך כאילו היה מצביע int *ptr; int array[10]; ptr = array; ptr[2] = 25; *array = 4;

4. למה צריך מצביעים ? ✝ משתנה ניתן לשנות את ערכו אך ורק בפונקציה בה הוגדר מצביע נותן לנו גישה אל משתנים שהוגדרו בפונקציות אחרות דוגמא: הפונקציה scanf משנה ערכים של משתנים פונקציה יכולה לחשב מספר ערכים ולשמור אותם בכתובות שהועברו אליה (כמו להחזיר מספר ערכים מפונקציה) ✝ עוד סיבות בהמשך

5. מצביעים ומחרוזות מימוש strlen בעזרת מצביע int strlen(const char* str) } int len = 0; if (str == NULL) return -1; /* Error! */ while (*str != '\0') { len++; str++; } return len; }

6. 6 Today’s class Data The importance of fast access to data How can it be achieved? Preprocessing followed by fast retrieval The most basic data structure: arrays Preprocessing  sorting fast retrieval  searching Time complexity

7. Vast Data 7

8. Sorting A sorted array is an array that its elements are arranged in descending/ascending order One of the most common application on arrays An example of a sorted array: 1 25 678139 8

9. 9 What is Sorting Good For? Finding a number in an array Consider a large array (of length n) and multiple queries on whether a given number exists in the array (and what is its position in it) Naive solution: given a number, traverse the array and search for it Not efficient ~ n/2 steps for each search operation Can we do better? Sort the array as a preliminary step. Now search can be performed much faster!

10. Search in a Non-Sorted Array Search for value in array If value is not in array  return -1 Traverse the elements by the array’s order int regular_search(int array[], int size, int value) { int i; for (i = 0; i < size; i++) { if (array[i] == value) return i; } return -1; { 10

11. 11 Binary Search Input: A sorted array of integers A An integer query q Output: -1 if q is not a member of A The index of q in A otherwise Algorithm: Check the middle element of A If it is equal to q, return its index If it is >= q, search for q in A[0,…,middle-1] If it is < q, search for q in A[middle+1,...,end]

12. 12 An Example -5-30481122565797 value index 023 45 16 78 9

13. 13 Code – Binary Search int binarySearchRec(int arr[], int quary, int start, int end) { int middle; if (start > end) return -1; middle = start + (end-start) / 2; if (arr[middle] == quary) return middle; if (arr[middle] > quary) return binarySearchRec(arr,quary,start,middle-1); else return binarySearchRec(arr,quary,middle+1,end); }

14. 14 Code – Main int a [] = {-5,-3,0,4,8,11,22,56,57,97}; printf("%d\n",binarySearch(a,SIZE,0)); printf("%d\n",binarySearch(a,SIZE,-4)); printf("%d\n",binarySearch(a,SIZE,8)); printf("%d\n",binarySearch(a,SIZE,1)); printf("%d\n",binarySearch(a,SIZE,-5)); printf("%d\n",binarySearch(a,SIZE,9)); printf("%d\n",binarySearch(a,SIZE,7)); int binarySearch(int arr[], int size, int quary) { return binarySearchRec(arr,quary,0,size-1); }

15. 15 Output int a [] = {-5,-3,0,4,8,11,22,56,57,97}; printf("%d\n",binarySearch(a,SIZE,0)); printf("%d\n",binarySearch(a,SIZE,-4)); printf("%d\n",binarySearch(a,SIZE,8)); printf("%d\n",binarySearch(a,SIZE,1)); printf("%d\n",binarySearch(a,SIZE,-5)); printf("%d\n",binarySearch(a,SIZE,9)); printf("%d\n",binarySearch(a,SIZE,7));

16. 16 So, How Fast is it? Worst case analysis Size of the inspected array: n  n/2  n/4  …..  1 Each step is very fast (a small constant number of operations) There are log 2 (n) such steps So it takes ~ log 2 (n) steps per search Much faster then ~ n If n = 1,000,000 it will take ~ 20 step (instead of ~milion)

17. 17 A Word About Time Complexity Two common resources are space, measured by the number of deferred operations, and time, measured by the number of primitive steps What matters? Small instances are not “interesting” Quick operations are considered as constant What matters is the order of times that constant operations are performed Assume we have an array of size n = 1 million: Order of n 2 ~ constant * trillion (Tera) Order of n = constant * million (Mega) Order of log(n) = constant * 20

18. 18 An Example nlg nn lg nn2n2 1 001 16 464256 82,04865,536 4,096 1249,15216,777,216 65,536 161,048,5654,294,967,296 1,048,576 2020,971,5201,099,511,627,776 16,777,216 24402,653,183281,474,976,710,656

19. 19 Binary Search Using Pointers (“light”) int binarySearch(int arr [], int size, int quary) { return binarySearchRec(arr,quary,0,size-1); } int binarySearchRec(int arr[], int quary, int start, int end) { int middle; if (start > end) return -1; middle = start + (end - start)/2; if (*(arr + middle) == quary) return middle; if (*(arr + middle) > quary) return binarySearchRec(arr,quary,start,middle-1); else return binarySearchRec(arr,quary,middle+1,end); }

20. 20 Binary Search Using Pointers int * binarySearch(int arr [], int size, int quary) { return binarySearchRec(quary,arr,arr+size-1); } int * binarySearchRec(int quary, int * start, int * end) { int * middle; if (start > end) return NULL; middle = start + (end - start) / 2; if (*middle == quary) return middle; if (*middle > quary) return binarySearchRec(quary,start,middle-1); else return binarySearchRec(quary,middle+1,end); }

21. 21 Main & Output int a [] = {-5,-3,0,4,8,11,22,56,57,97}; int * ind = binarySearch(a,SIZE,0); if (ind != NULL) printf("%d\n",ind - a);

22. Iterative Binary Search 22 int binarySearch(int arr [], int size, int quary) { int start= 0, end = size - 1; int middle; while (start <= end) { middle = (start + end) / 2; if (quary == arr [middle]) return middle; if (quary < arr [middle]) end = middle - 1; if (quary > arr [middle]) start = middle + 1; } return -1; }

23. Add an Element to a Sorted Array Input: input array and the value 10 Step by step: 1 2567 8139 ?10< 1 25 678139 ?10< 6713 10 23

24. Add an Element to a Sorted Array /* * Requires: * 1. The elements of the array are sorted in ascending order. * 2. length < capacity * length is the current number of elements in the array * capacity is the maximum number of elements array */ void array_add(int array[], int length, int value) { int i, j; for (i = 0; i < length && array[i] <= value; i++); for (j = length; j > i; j--) array[j] = array[j - 1]; array[i] = value; { 24

25. Cons and Pros of Arrays 25 Direct access (random access) Fast search (for sorted arrays) Fast access Less appropriate for dynamic operations Add element Remove element Update element (remove + add) We will study data structure that have the second bullet properties later in the course

26. Bubble Sort 26 Repeatedly stepping through the array to be sorted, comparing each pair of adjacent items and swapping them if they are in the wrong order The pass through the array is repeated until no swaps are needed  the array is sorted “Bubbles” the correct elements to the top of the array

27. 27 Bubble Sort Example 7 2854 2 7854 2 7854 2 7584 2 7548 2 7548 2 5748 2 5478 2 7548 2 5478 2 4578 2 5478 2 4578 2 4578 (done)

28. 28 Bubble Sort Code void bubbleSort(int arr[], int size) { int i,j,tmp; for (i = size - 1; i > 0; --i) for (j = 0; j < i; ++j) if (arr[j] > arr[j+1]) { // swap tmp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = tmp; }

29. 29 Bubble Sort Code int main() { int i, a [] = {7,2,8,5,4}; bubbleSort(a,SIZE); for (i = 0; i < SIZE; ++i) printf("%d ",a[i]); printf("\n"); return 0; }

30. void bubbleSort(int arr[], int size) { int i,j; for (i = size - 1; i > 0; --i) for (j = 0; j < i; ++j) if (arr[j] > arr[j+1]) { // swap (with trick) arr[j] = arr[j] + arr[j+1]; arr[j+1] = arr[j] - arr[j+1]; arr[j] = arr[j] - arr[j+1]; } 30 Bubble Sort Time Complexity Array of size n n iterations i iterations constant (n-1 + n-2 + n-3 + …. + 1) * const ~ ½ * n 2

31. 31 Time Complexity Examples Find a maximum in a general array Find the maximum in a sorted array Find the 5 th largest element in a sorted array Answer n Fibonacci quarries, each limited by MAX Find an element in a general array Find an element in a sorted array

32. 32 The Idea Behind Merge Sort A small list will take fewer steps to sort than a large list Fewer steps are required to construct a sorted list from two sorted lists than two unsorted lists

33. 33 Merge Sort Algorithm If the array is of length 0 or 1, then it is already sorted. Otherwise: Divide the unsorted array into two sub- arrays of about half the size Sort each sub-array recursively by re- applying merge sortrecursively Merge the two sub-arrays back into one sorted arrayMerge

34. 34 Merge Sort (partial) Code void mergeSortRec(int arr[], int start, int end) { middle = (end - start) / 2; if ((end - start) < 2) return; mergeSortRec(arr,start,middle); mergeSortRec(arr,middle+1,end); mergeArrays(arr,start,middle,middle+1,end); } void mergeSort(int arr [], int size) { return mergeSortRec(arr,0,size-1); }

35. 35 Merge Sort Example

36. 36 Merge Sort Time Complexity If the array is of length 0 or 1, then it is already sorted. Otherwise: Divide the unsorted array into two sub-arrays of about half the size Sort each sub-array recursively by re-applying merge sortrecursively Merge the two sub-arrays back into one sorted arrayMerge n + 2 * (n/2) + 2 2 * n/2 2 + 2 3 * n/2 3 + … + 2 log(n) * n/2 log(n) = n + n + … + n = (n+1) * log(n) log(n) +1

37. 37 Bucket Sort Linear-time sorting algorithm! But: restrictions on data – bounded integers…

38. 38 Sorting Strings So far we only sorted numbers How would we sort strings? Lexicographical order ( מילוני ) To be continued in tirgul…

39. 39 “Generic” Sort Sort an array of int/long/double/float/char in descending/ascending order What is the difference between these cases? Algorithmically the same! Code duplication 

40. 40 The Idea Behind“Generic” Sort (Cont.) Sort an array of int/long/double/float/char in descending/ascending order What are the parameters? Array type Comparison between array elements Sort (array type arr, comperator comp) { … if (comp(arr[i],arr[j]) < 0) swap … }

41. 41 Implementation Sketch in C Memory Comperator code array