1. Instructor: Alexander Stoytchev http://www.ece.iastate.edu/~alexs/classes/2009_Fall_185/ CprE 185: Intro to Problem Solving (using C)

2. Administrative Stuff HW6 is today (Oct 21) @ 8pm. HW7 is due this Friday (Oct 23) @ 8pm.

3. Administrative Stuff Midterm 2 is next week  Same format as before:  Lab exam during your regular lab time (Oct 27 or Oct 28)  Lecture exam on Oct 28 The exam will be cumulative with emphasis on conditional statements (if, if-else, switch), loops (do, while, for), arrays (to be covered), and searching and sorting algorithms (to be covered).

4. Linear Search in a Sorted Array

5. Problem: Find the index of a number in a sorted array of integers LinearSearch_InSortedArray.c

6. LinearSearch_InSortedArray.c #include #define N 12 int main() { int a[N]= { 4, 7, 8, 10, 14, 21, 22, 36, 62, 77, 81, 91}; int target = 62;//int target = 72;// Try this target next int i, idx=-1; for(i=0; i< N; i++) { if(a[i] == target) { idx=i; break; } else if(a[i]>target) break; // we can stop here } if(idx == -1) printf("Target not found.\n\n"); else printf("Target found at index: %d. \n\n", idx); }

7. Analysis If the list is unsorted we have to search all numbers before we declare that the target is not present in the array. Because the list is sorted we can stop as soon as we reach a number that is greater than our target Can we do even better?

8. Binary Search At each step it splits the remaining array elements into two groups Therefore, it is faster than the linear search Works only on an already SORTED array Thus, there is a performance penalty for sorting the array [http://web.ics.purdue.edu/~cs154/lectures/lecture011.htm]

9. Example: Successful Binary Search

10. Example: BinarySearch.c

11. Binary_Search.c #include #define N 12 int main() { int a[N]= { 4, 7, 8, 10, 14, 21, 22, 36, 62, 77, 81, 91}; //sorted in increasing order int i; int target = 22;//int target = 72; // Try this target next int idx=-1; // if the target is found its index is stored here int first=0; // initial values for the three search varaibles int last= N-1; int mid= (first + last)/2; while(last >= first) { if( a[mid] == target) { idx=mid; // Found it! break; // exit the while loop } else if(a[mid] > target) { // don't search in a[mid]... a[last] last = mid-1; } else { // don't search in a[first]... a[mid] first = mid +1; } // recalculate mid for the next iteration mid = (first + last)/2; // integer division! } // end of while loop if(idx == -1) printf("Target not found.\n\n"); else printf("Target found at index: %d \n\n", idx); }

13. Analysis of Searching Methods For an array of size n Sequential Search (Average-Case) n/2 Sequential Search (Worst-Case) n Binary Search (Average-Case) log(n)/2 Binary Search (Worst-Case) log(n)

14. Other Stuff in Chapter 8

15. Two-Dimensional Arrays int Matrix[2][3]; Defines the following elements:  Row1: Matrix[0][0], Matrix[0][1], Matrix[0][2]  Row2: Matrix[1][0], Matrix[1][1], Matrix[1][2]

16. Two-Dimensional Arrays int Matrix[2][3]; Initialization: Matrix[0][0]=3; Matrix[0][1]=4; Matrix[0][2]=5; Matrix[1][0]=1; Matrix[1][1]= -20; Matrix[1][2]=7;

17. Two-Dimensional Arrays Initialization when defined: int Matrix[2][3] = { {3, 4, 5}, {1, -20, 7}};

18. Two-Dimensional Arrays 2D arrays and nested for loop int Matrix[2][3] = { {3, 4, 5}, {1, -20, 7}}; int i,j; for(i=0; i< 2; i++) { for(j=0; j<3; j++) printf(“%3d ”, Matrix[i][j]); printf(“\n”); }

19. Sorting Algorithms CprE 185: Intro to Problem Solving Iowa State University, Ames, IA Copyright © Alexander Stoytchev

20. Chapter 8 (Sorting)

21. Insertion Sort [http://web.ics.purdue.edu/~cs154/lectures/lecture010.htm] 0

22. Analogy: Sorting Cards

24. First Iteration First Iteration (All face up cards are sorted. End of the first iteration.)

25. Second Iteration Second Iteration (All face up cards are sorted. End of the second iteration.)

26. Third Iteration Third Iteration (All face up cards are sorted. End of the third iteration.)

27. Fourth Iteration Fourth Iteration (All face up cards are sorted. End of the fourth iteration.)

28. Fifth Iteration Fifth Iteration (All face up cards are sorted. End of the fifth iteration.)

29. Swapping Array Elements [http://www.scs.ryerson.ca/jpanar/w2006/cps125/example.gifs/ch7/Arr.Swap.gif]

30. First Iteration (array-like swapping) First Iteration (All face up cards are sorted. End of the first iteration.)

31. Second Iteration (array-like swapping) Second Iteration (All face up cards are sorted. End of the second iteration.)

32. [http://web.ics.purdue.edu/~cs154/lectures/lecture010.htm] Example: Insertion Sort

33. Animations for Insertion Sort [http://maven.smith.edu/~thiebaut/java/sort/demo.html]

34. Animations of Sorting Algoritms http://maven.smith.edu/~thiebaut/java/sort/demo.html http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html

35. C code // Swap a[i] with the smallest element int temp = a[i]; a[i] = a[minIndex]; a[minIndex] = temp;

36. Example: InsertionSort.c

37. // Insertion Sort #include #define N 6 int main() { int a[N]= { 23, 78, 45, 8, 32, 56}; int i; for(i = 1; i < N; i++) { int j = i; int INS = a[i]; while ((j > 0) && (a[j-1] > INS)) { a[j] = a[j-1]; // shift elements to the right j--; } a[j] = INS; // insert the element } system("pause"); }

38. Selection Sort (Cards Example)

39. Initial Configuration (search all cards and find the largest)

40. Swap the two cards

41. As before, the swap is performed in three steps.

42. SortedUnsorted Among the remaining cards the king is the largest. It will remain in place. But the algorithm may perform Some empty operations (ie., swap it with itself in place)

43. SortedUnsorted Among the remaining cards the queen is the largest. It will remain in place. But the algorithm may perform Some empty operations (i.e., swap it with itself in place)

44. SortedUnsorted Among the remaining cards the Jack is the largest. It will remain in place. But the algorithm may perform Some empty operations (i.e., swap it with itself in place)

45. As before, the swap is performed in three steps.

46. SortedUnsorted We are down to the last card. Because there is only one and Because we know that it is Smaller than all the rest We don’t need to do anything Else with it. This is why the Algorithm goes up to < N-1

47. Sorted All cards are now sorted.

48. Selection Sort [http://web.ics.purdue.edu/~cs154/lectures/lecture010.htm]

49. Example: Selection Sort [http://web.ics.purdue.edu/~cs154/lectures/lecture010.htm]

50. Example: SelectionSort.c

51. // Selection Sort #include #define N 6 int main() { int a[N]= { 23, 78, 45, 8, 32, 56}; int i,j; // Sort the array using Selection Sort int minIndex; for(i=0; i < N-1; i++) { // find the minimum element in the unsorted part of the array minIndex=i; for(j=i+1; j < N; j++) if(a[j] < a[minIndex]) minIndex = j; // Swap a[i] with the smallest element int temp = a[i]; a[i] = a[minIndex]; a[minIndex] = temp; } system("pause"); }

52. Bubble Sort (Cards Example)

53. Initial Configuration Unsorted

54. First iteration of the outer loop

55. End of the first iteration (the smallest card is placed last) SortedUnsortedSortedUnsorted

56. End of the 2nd iteration (the smallest two cards are placed last) 2nd Iteration SortedUnsorted

57. End of the 3rd iteration (the smallest three cards are placed last) 3rd Iteration SortedUnsorted

58. End of the 4-th iteration all cards are sorted 4-th Iteration SortedUnsorted Sorted The last card (the Ace) Is automatically sorted. We don’t need to do anything extra.

59. Bubble Sort [http://web.ics.purdue.edu/~cs154/lectures/lecture010.htm] 0

60. Example: Bubble Sort

61. Example: BubbleSort.c

62. // Bubble Sort #include #define N 6 int main() { int a[N]= { 23, 78, 45, 8, 32, 56}; int i, j; // Sort the array using Bubble Sort // Last elements in the array are sorted first (in decreasing order) for(i=0; i < N; i++) { for(j=0; j< N-1-i; j++) if (a[j+1] > a[j]) /* compare the two neighbors */ { int tmp = a[j]; /* swap a[j] and a[j+1] */ a[j] = a[j+1]; a[j+1] = tmp; }

63. Analysis: all three run in O(n 2 ) time [http://linux.wku.edu/~lamonml/algor/sort/sort.html]

64. Analysis There are faster sorting algorithms  Heap sort  Quick sort  Merge Sort We will not cover those but feel free to study them on your own. They run in O(n log n) time.

65. O(n log n) sorting algorithms [http://linux.wku.edu/~lamonml/algor/sort/sort.html]

66. Questions?

67. THE END