Searching & Sorting. Definitions of Search and Sort. Other forms of Linear Search. Linear Search. Week 11. Gaddis: 8, 19.6,19.8. CS 5301 Spring 2017

Transcription

1 Searching & Sorting Week 11 Gaddis: 8, 19.6,19.8 CS 5301 Spring 2017 Ji Seaman 1 Definitions of Search and Sort Search: find a given item in a ist, return the position of the item, or -1 if not found. Sort: rearrange the items in a ist into some order (smaest to biggest, aphabetica order, etc.). ist coud be: array, inked ist, string, etc. There are various methods (agorithms) for carrying out these common tasks. 2 Linear Search Other forms of Linear Search Compare first eement to target vaue, if not found then compare second eement to target vaue... Repeat unti: target vaue is found (return its position) or we run out of items (return -1). int searchlist (int ist[], int size, int vaue) for (int i=0; i<size; i++) if (ist[i] == vaue) return i; return -1; 3 Recursive inear search over arrays Gaddis ch 19, Prog Chaenge #8: ismember Linear search over inked ist Gaddis ch 17, Prog Chaenge #5: List search Recursive inear search over inked ist Another good exercise 4

2 Binary Search Works ony for SORTED arrays Divide and conquer stye agorithm Compare target vaue to midde eement in ist. if equa, then return its index if ess than midde eement, repeat the search in the first haf of ist if greater than midde eement, repeat the search in ast haf of ist If current search ist is narrowed down to 0 target is 11 target < 50 target > 7 Binary Search Agorithm exampe target == 11 first first first ast ast ast eements, return Binary Search in C++ Iterative version int binarysearch (int array[], int size, int target) int first = 0, ast = size 1, midde, position = -1; boo found = fase; whie (first <= ast &&!found) midde = (first + ast) /2; //index to (current) first eem //index to (current) ast eem //index of (current) midde eem //index of target vaue //fag //cacuate midpoint if (array[midde] == target) found = true; position = midde; ese if (target < array[midde]) ast = midde 1; //search ower haf ese first = midde + 1; //search upper haf return position; 7 Binary Search in C++ Recursive version int binarysearchrec(int array[], int first, int ast, int vaue) int midde; // Mid point of search if (first > ast) //check for empty ist return -1; midde = (first + ast)/2; //compute midde index if (array[midde]==vaue) return midde; if (vaue < array[midde]) //recursion return binarysearchrec(array, first,midde-1, vaue); ese return binarysearchrec(array, midde+1,ast, vaue); int binarysearch(int array[], int size, int vaue) return binarysearchrec(array, 0, size-1, vaue); 8

3 What is sorting? Seection Sort Sort: rearrange the items in a ist into ascending or descending order - numerica order - aphabetica order - etc There is a pass for each position (0..size-1) On each pass, the smaest (minimum) eement in the rest of the ist is exchanged (swapped) with eement at the current position. The first part of the ist (the part that is aready processed) is aways sorted Each pass increases the size of the sorted portion. 10 Seection sort Exampe Seection sort: code pass 1: minimum is 6, swap pass 2: minimum is 10, swap pass 3: minimum is 12, swap pass 4: minimum is 24, swap sorted Note: first n eements are sorted after pass n // Returns the index of the smaest eement, starting at start int findindexofmin (int array[], int size, int start) int minindex = start; for (int i = start+1; i < size; i++) if (array[i] < array[minindex]) minindex = i; return minindex; // Sorts an array, using findindexofmin void seectionsort (int array[], int size) int minindex; for (int index = 0; index < (size -1); index++) minindex = findindexofmin(array, size, index); swap(array[minindex],array[index]); 11 12

4 On each pass: Bubbe sort - Compare first two eements. If the first is bigger, they exchange paces (swap). - Compare second and third eements. If second is bigger, exchange them. - Repeat unti ast two eements of the ist are compared. Repeat this process unti a pass competes with no exchanges Bubbe sort Exampe 7 > 2, swap 7 > 3, swap!(7 > 8), no swap!(8 > 9), no swap 9 > 1, swap finished pass 1, did 3 swaps Note: argest eement is in ast position Bubbe sort Exampe 2<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 7<8<9, no swap finished pass 3, did one swap 2 argest eements in ast 2 positions 3 argest eements in ast 3 positions Bubbe sort Exampe <3,!(3<1) swap, 3<7<8< finished pass 4, did one swap !(2<1) swap, 2<3<7<8< finished pass 5, did one swap <2<3<7<8<9, no swaps finished pass 6, no swaps, ist is sorted! 15 16

5 Bubbe sort how does it work? At the end of the first pass, the argest eement is moved to the end (it s bigger than a its neighbors) At the end of the second pass, the second argest eement is moved to just before the ast eement. The back end (tai) of the ist remains sorted. Each pass increases the size of the sorted portion. No exchanges impies each eement is smaer Bubbe sort: code tempate<cass ItemType> void bubbesort (ItemType a[], int size) boo swapped; do swapped = fase; for (int i = 0; i < (size-1); i++) if (a[i] > a[i+1]) swap(a[i],a[i+1]); swapped = true; whie (swapped); than its next neighbor (so the ist is sorted) Divide and conquer! Quick sort 2 (hopefuy) haf-sized ists sorted recursivey the agorithm: Quicksort Exampe. - If ist size is 0 or 1, return. otherwise: - partition into two ists: pick one eement as the pivot put a eements ess than pivot in first haf put a eements greater than pivot in second haf - recursivey sort first haf and then second haf of ist

6 Quicksort: partitioning Goa: partition a sub-array so that: - A[x]<=A[p] for x<p and A[x]>=A[p] for x>p pick midde as pivot, swap to front, pivotindex=0 compare each eem to pivot, if eem<6, increment pivotindex, swap >6, continue <6, pivotindex++ and swap <6, pivotindex++ and swap <6, pivotindex++ and swap and 12 not ess than 6, don t swap After the scan, swap A[start] with A[pivotIndex], return pivotindex Quicksort: code void quicksort(int set[], int start, int end) if (start < end) // Get the pivot point (and partition the set). int pivotpoint = partition(set, start, end); // Sort the first sub ist. quicksort(set, start, pivotpoint - 1); // Sort the second sub ist. quicksort(set, pivotpoint + 1, end); return 3 as index of pivot (6) void quicksort (int set[], int size) quicksort(set, 0, size-1); Quicksort: code int partition(int set[], int start, int end) int mid = (start + end) / 2; // ocate the pivot vaue swap(set[start], set[mid]); int pivotindex = start; int pivotvaue = set[start]; for (int scan = start + 1; scan <= end; scan++) // finds vaues ess than pivotvaue and // moves them to the (eft of the) pivotindex if (set[scan] < pivotvaue) pivotindex++; swap(set[pivotindex], set[scan]); swap(set[start], set[pivotindex]); //put pivot back in pace return pivotindex; 23