! Search: find an item in an array, return the. ! Sort: rearrange the items in an array into some. ! There are various methods (algorithms) for

Transcription

1 Ch 8. earching and orting Arrays 8.1 and 8.3 only C 2308 pring 2013 Jill eaman efinitions of earch and ort! earch: find an item in an array, return the index to the item, or -1 if not found.! ort: rearrange the items in an array into some order (smallest to biggest, alphabetical order, etc.).! here are various methods (algorithms) for carrying out these common tasks.! Which ones are better? Why? 1 2 Linear earch Linear earch in C++! Very simple method.! Compare first element to target value, if not found then compare second element to target value...! epeat until: target value is found (return its index) or we run out of items (return -1). int searchlist (int list[], int numlems, int value) { int index=0; int position = -1; bool found = false; //index to process array //position of value //flag, true when value is found while (index < numlems &&!found) { if (list[index] == value) //found the value! { found = true; //set the flag position = index; //record which item index++; return position; //increment loop index 3 What if we don t use found? 4

2 Program using Linear earch #include <iostream> using namespace std; int searchlist(int[], int, int); int main() { const int IZ=5; int idums[iz] = {871, 750, 988, 0, 822; int results, id; cout << nter the employee I to search for: ; cin >> id; results = searchlist(idums, IZ, id); if (results == -1) { cout << hat id number is not registered\n ; else { cout << hat id number is found at location ; cout << results+1 << endl; return 0; 5 valuating the Algorithm! Is it efficient? oes it do any unnecessary work?! We measure efficiency of algorithms in terms of number of main steps required to finish.! For search algorithms, the main step is comparing an array element to the target value.! umber of steps depends on: size of input array whether or not value is in array where the value is in the array fficiency of Linear earch Binary earch Best Case: Average Case: Worst Case: =50,000 In terms of ,000 /2 50,000 * is the number of elements in the array ote: if we search for items not in the array, the average case will increase. 7! Works only for arrays! ivide and conquer style algorithm! Compare target value to middle element in list. if equal, then return its index if less than middle element, search in first half of list (repeat) if greater than middle element, search in last half of list (repeat)! If current search list is narrowed down to 0 elements, return -1 8

3 Binary earch Algorithm! he algorithm described in pseudocode: while (number of items in list >= 1) and (target not found) if (item at middle position is equal to target) target is found! location = middle position else if (target < middle item) (narrow search list) list = lower half of list else list = upper half of list end while if target not found, location = -1 9 Binary earch in C++ int binaryearch (int array[], int numlems, int value) { int first = 0, //index to first elem last = numlems 1, //index to last elem middle, //index of middle elem position = -1; //index of target value bool found = false; //flag while (first <= last &&!found) { middle = (first + last) /2; if (array[middle] == value) { found = true; position = middle; else if (array[middle] > value) { last = middle 1; else { first = middle + 1; return position; //calculate midpoint What if first + last is odd? What if first==last? //search lower half //search upper half Binary earch xample xam Question! he target of your search is 42. Given the following list of integers, record the values of first, last, and middle during a binary search. Assume the following numbers are in an array.! !! epeat the exercise with a target of 82 Program using Binary earch #include <iostream> using namespace std; int binaryearch(int[], int, int); How is this program different from the one on slide 5? int main() { const int IZ=5; int idums[iz] = {0, 750, 822, 871, 988; int results, id; cout << nter the employee I to search for: ; cin >> id; first last 14 middle first last middle ote: these are the indexes, not the values in the array 11 5 results = binaryearch(idums, IZ, id); if (results == -1) { cout << hat id number is not registered\n ; else { cout << hat id number is found at location ; cout << results+1 << endl; return 0;

4 fficiency of Binary earch Calculate worst case for = Items left to search Comparisons so far = 2 <==> log 2 = Goal: calculate this value from 13 fficiency of Binary earch If is the number of elements in the array, how many comparisons (steps)? = 2 <==> log 2 = = 2 steps Best Case: Worst Case: <==> log 2 = steps =50,000 In terms of log 2 o what power do I raise 2 to get? ounded up to next whole number 14 Is Log 2 better than? Is binary search better than linear search? Compare values of /2,, and Log 2 as increases: /2 Log ,000 2, ,000 25, and /2 are growing much faster than log! slower growing is more efficient (fewer steps). Is this really a fair comparison? 15 Classifications of (math) functions Constant f(x)=b (1) Logarithmic f(x)=logb(x) (log n) Linear f(x)=ax+b (n) Linearithmic f(x)=x logb(x) (n log n) Quadratic f(x)=ax 2 +bx+c (n 2 ) xponential f(x)=b x (2 n )! Last column is big h notation, used in C.! It ignores all but dominant term, constant factors 1

5 Comparing growth of functions fficiency of Algorithms! o classify efficiency of an algorithm: ime (# of steps) xpress time (using number of main steps or comparisons), as a function of input size etermine which classification the function fits into.! earer to the top of the chart is slower growth, and more efficient (constant is better than logarithmic, etc.) ata size () orting Algorithms Why is sorting important?! ort: rearrange the items in an array into ascending or descending order.! earching in a sorted list is much easier than searching in an unsorted list.! specially for people! election ort! Bubble ort unsorted 19 sorted - dictionary entries - phone book - card catalog in library - bank statement: transactions in date order! Most of the data displayed by computers is sorted. 20

6 election ort election ort: Pass ne! here is a pass for each position (0..size-1)! n each pass, the smallest (minimum) element in the rest of the list is exchanged (swapped) with element at the current position.! he first part of the list (the part that is already processed) is always sorted! ach pass increases the size of the sorted portion U 5 election ort: nd Pass ne election ort: Pass wo 3 U 3 U 7

7 election ort: nd Pass wo election ort: Pass hree 3 U 3 U 8 9 election ort: nd Pass hree election ort: Pass Four 3 U 3 U 11

8 election ort: nd Pass Four election ort in C++ 3 // eturns the index of the smallest element, starting at start int findindexfmin (int array[], int size, int start) { int minindex = start; for (int i = start+1; i < size; i++) { ote: saving the index if (array[i] < array[minindex]) { minindex = i; return minindex; We need to find the index of the minimum value so that we can do the swap // orts an array, using findindexfmin void selectionort (int array[], int size) { int temp; int minindex; for (int index = 0; index < (size -1); index++) { minindex = findindexfmin(array, size, index); //swap temp = array[minindex]; array[minindex] = array[index]; array[index] = temp; 30 Program using election ort #include <iostream> using namespace std; int findindexfmin (int [], int, int); void selectionort(int [], int); void showarray(int [], int); int main() { int values[] = {7, 2, 3, 8, 9, 1; cout << he unsorted values are: \n ; showarray (values, ); selectionort (values, ); cout << he sorted values are: \n ; showarray(values, ); void showarray (int array[], int size) { for (int i=0; i<size; i++) cout << array[i] << ; cout << endl; utput: he unsorted values are: he sorted values are: fficiency of election ort! is the number of elements in the list! uter loop (in selectionort) executes -1 times! Inner loop (in minindex) executes -1, then -2, then -3,... then once.! otal number of comparisons (in inner loop): (-1) + (-2) = sum of 1 to -1 ote: + (-1) + (-2) = (+1)/2 ubtract from each side: (-1) + (-2) = (+1)/2 - = ( 2 +-2)/2 = 2 /2 - /2 ( 2 ) 32

9 he Bubble ort Bubble sort xample! n each pass: - Compare first two elements. If the first is bigger, they exchange places (swap). - Compare second and third elements. If second is bigger, exchange them. - epeat until last two elements of the list are compared.! epeat this process until a pass completes with no exchanges 33! > 2, swap! > 3, swap! !(7 > 8), no swap! !(8 > 9), no swap! > 1, swap! finished pass 1, did 3 swaps ote: largest element is in last position 34 Bubble sort xample! <3<7<8, no swap,!(8<1), swap! (8<9) no swap! finished pass 2, did one swap! <3<7, no swap,!(7<1), swap! <8<9, no swap! finished pass 3, did one swap 2 largest elements in last 2 positions 3 largest elements in last 3 positions 35 Bubble sort xample! <3,!(3<1) swap, 3<7<8<9! ! finished pass 4, did one swap! !(2<1) swap, 2<3<7<8<9! ! finished pass 5, did one swap! <2<3<7<8<9, no swaps! finished pass, no swaps, list is sorted! 3

10 Bubble sort how does it work?! At the end of the first pass, the largest element is moved to the end (it s bigger than all its neighbors)! At the end of the second pass, the second largest element is moved to just before the last element.! he back end (tail) of the list remains sorted.! ach pass increases the size of the sorted portion.! o exchanges implies each element is smaller than its next neighbor (so the list is sorted). 37 Bubble ort in C++ void bubbleort (int array[], int size) { bool swap; int temp; do { swap = false; for (int i = 0; i < (size-1); i++) { if (array [i] > array[i+1]) { temp = array[i]; array[i] = array[i+1]; array[i+1] = temp; swap = true; while (swap); 38 Program using bubble sort #include <iostream> using namespace std; void bubbleort(int [], int); void showarray(int [], int); int main() { int values[] = {7, 2, 3, 8, 9, 1; fficiency of Bubble ort! ach pass makes -1 comparisons! here will be at most passes cout << he unsorted values are: \n ; showarray (values, ); bubbleort (values, ); cout << he sorted values are: \n ; showarray(values, ); void showarray (int array[], int size) { for (int i=0; i<size; i++) cout << array[i] << ; cout << endl; utput: he unsorted values are: he sorted values are: ! o worst case it s: (-1)* = 2 - ( 2 )! If you change the algorithm to look at only the unsorted part of the array in each pass, it s exactly like the selection sort: (-1) + (-2) = 2 /2 - /2 still ( 2 ) 40