Cpr E 185 Intro to Problem Solving using

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

Administrative Stuff • HW 6 is today (Oct 21) @ 8 pm. • HW 7 is due this Friday (Oct 23) @ 8 pm.

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

Linear Search in a Sorted Array

Problem: Find the index of a number in a sorted array of integers Linear. Search_In. Sorted. Array. c

Linear. Search_In. Sorted. Array. c #include <stdio. h> #include <stdlib. h> #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. nn"); else printf("Target found at index: %d. nn", idx); }

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?

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/~cs 154/lectures/lecture 011. htm]

Example: Successful Binary Search [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 011. htm]

Example: Binary. Search. c

Binary_Search. c #include <stdio. h> #include <stdlib. h> #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. nn"); else printf("Target found at index: %d nn", idx); }

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

Other Stuff in Chapter 8

Two-Dimensional Arrays • int Matrix[2][3]; • Defines the following elements: § Row 1: Matrix[0][0], Matrix[0][1], Matrix[0][2] § Row 2: Matrix[1][0], Matrix[1][1], Matrix[1][2]

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;

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

Two-Dimensional Arrays • 2 D 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(“%3 d ”, Matrix[i][j]); printf(“n”); }

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

Chapter 8 (Sorting)

Insertion Sort 0 [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

Analogy: Sorting Cards

Analogy: Sorting Cards

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

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

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

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

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

Swapping Array Elements [http: //www. scs. ryerson. ca/jpanar/w 2006/cps 125/example. gifs/ch 7/Arr. Swap. gif]

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

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

Example: Insertion Sort [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

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

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

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

Example: Insertion. Sort. c

// Insertion Sort #include <stdlib. h> #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"); }

Selection Sort (Cards Example)

Initial Configuration (search all cards and find the largest)

Swap the two cards

As before, the swap is performed in three steps.

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

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

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

As before, the swap is performed in three steps.

Sorted Unsorted 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

All cards are now sorted. Sorted

Selection Sort [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

Example: Selection Sort [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

Example: Selection. Sort. c

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

Bubble Sort (Cards Example)

Initial Configuration Unsorted

First iteration of the outer loop

End of the first iteration (the smallest card is placed last) Unsorted Sorted

2 nd Iteration End of the 2 nd iteration Unsorted Sorted (the smallest two cards are placed last)

3 rd Iteration End of the 3 rd iteration (the smallest three cards are placed last) Unsorted Sorted

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

Bubble Sort 0 [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

Example: Bubble Sort [http: //web. ics. purdue. edu/~cs 154/lectures/lecture 010. htm]

Example: Bubble. Sort. c

// Bubble Sort #include <stdlib. h> #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; } } }

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

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.

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

Questions?

THE END