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

2. 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 2

3. Vast Data 3 3

4. 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 2 5 67 8 13 9

5. 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!

6. 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;

7. Binary Search Input: Output: Algorithm: 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]

8. An Example
index 2 3 4 5 1 6 7 8 9
value -5 -3 4 8 11 22 56 57 97

9. Code – Binary Search
int binarySearchRec(int arr[], int quary, int start, int end) {
int middle;
if (start > end)
return -1;
middle = (start + end) / 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); }

10. 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); }

11. 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));

12. 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 log2(n) such steps
So it takes ~ log2(n) steps per search
Much faster then ~ n
If n = 1,000,000 it will take ~ 20 step (instead of ~milion)

13. 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 n2 ~ constant * trillion (Tera)
Order of n = constant * million (Mega)
Order of log(n) = constant * 20 13

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

15. Iterative Binary Search
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;

16. 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;

17. Add an Element to a Sorted Array
קלט לפונקציה - המערך
והמספר 10
שלב אחרי שלב: 1 2 5 8 9 13 67 1 2 5 8 9 13 10 67 13 67
?10<
?10<
?10<
?10<
?10<
?10<

18. Add an Element to a Sorted Array
Input: input array and the
value 10
Step by step: 1 2 5 8 9 13 67 1 2 5 8 9 13 10 67 13 67
?10<
?10<
?10<
?10<
?10<
?10< 18 18

19. Cons and Pros of Arrays 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

20. Bubble Sort
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 20 20

21. Bubble Sort Example 7 2 8 5 4 2 7 5 4 8 2 5 4 7 8 2 4 5 7 8 2 7 8 5 4 2 7 5 4 8 2 5 4 7 8 2 4 5 7 8 2 7 8 5 4 2 5 7 4 8 2 4 5 7 8
(done) 2 7 5 8 4 2 5 4 7 8 2 7 5 4 8

22. Bubble Sort Code 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]; }

23. 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; }

24. Bubble Sort Time Complexity Array of size n
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]; }
n iterations
i iterations
constant
(n-1 + n-2 + n-3 + …. + 1) * const ~ ½ * n2 24

25. Time Complexity Examples
Find a maximum in a general array
Find the maximum in a sorted array
Find the 5th 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 25

26. 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 26

27. 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 sort
Merge the two sub-arrays back into one sorted array 27

28. Merge Sort Code
פתוח? 28

29. 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 sort
Merge the two sub-arrays back into one sorted array
n + 2 * (n/2) + 22 * n/ * n/23 + … + 2log(n) * n/2log(n) =
n + n + … + n = (n+1) * log(n)
log(n) +1 29

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

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

32. “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  32

33. 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 } 33

34. Implementation Sketch in C
Comperator
code
array
Memory 34

35. לתרגול – אחד מהשניים (והשני לשיעורי בית)

36. לתרגול 36

37. רעיונות לחומר לתרגול מילון - מיון של מילים חיפוש במילון...
אפשר לתת כמה קטעי קוד לדבר על זמני ריצה, לדוגמא: חיפוש על מערך שבכל שלב מגרילים אינדקס רנדומי
פיבונאצ'י רקורסיבי עם זיכרון (memoization) – למתי יש את הקוד, לאסף חש כמה שקפים רלוונטיים