Searching and Sorting Arrays

Slides:



Advertisements
Similar presentations
Lesson 8 Searching and Sorting Arrays 1CS 1 Lesson 8 -- John Cole.
Advertisements

Copyright © 2014, 2008 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Starting Out with C++ Early Objects Eighth Edition by Tony Gaddis,
Copyright © 2010 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Starting Out with Programming Logic & Design Second Edition by Tony Gaddis.
Chapter 9: Searching, Sorting, and Algorithm Analysis
 Sort: arrange values into an order  Alphabetical  Ascending numeric  Descending numeric  Does come before or after “%”?  Two algorithms considered.
Copyright © 2012 Pearson Education, Inc. Chapter 8: Searching and Sorting Arrays.
Starting Out with C++, 3 rd Edition 1 Chapter 8 – Searching and Sorting Arrays.
Searching Arrays Linear search Binary search small arrays
1 Algorithms and Analysis CS 2308 Foundations of CS II.
Searching and Sorting Arrays
Searching1 Searching The truth is out there.... searching2 Serial Search Brute force algorithm: examine each array item sequentially until either: –the.
Starting Out with C++: Early Objects 5/e © 2006 Pearson Education. All Rights Reserved Starting Out with C++: Early Objects 5 th Edition Chapter 9 Searching.
Chapter 8 ARRAYS Continued
Week 11 Introduction to Computer Science and Object-Oriented Programming COMP 111 George Basham.
Copyright © 2010 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Chapter 8: Searching and Sorting Arrays.
Copyright © 2012 Pearson Education, Inc. Chapter 8: Searching and Sorting Arrays.
CHAPTER 09 Compiled by: Dr. Mohammad Omar Alhawarat Sorting & Searching.
SEARCHING UNIT II. Divide and Conquer The most well known algorithm design strategy: 1. Divide instance of problem into two or more smaller instances.
Chapter 8 Searching and Sorting Arrays Csc 125 Introduction to C++ Fall 2005.
Copyright 2004 Scott/Jones Publishing Alternate Version of STARTING OUT WITH C++ 4 th Edition Chapter 9 Searching Arrays.
Starting Out with C++, 3 rd Edition 1 Searching an Arrays.
Copyright © 2015, 2012, 2009 Pearson Education, Inc., Publishing as Addison-Wesley All rights reserved. Chapter 8: Searching and Sorting Arrays.
Chapter Searching and Sorting Arrays 8. Introduction to Search Algorithms 8.1.
Lecture 16: Searching and Sorting Arrays Professor: Dr. Miguel Alonso Jr. Fall 2008 CGS2423/COP1220.
CSC 211 Data Structures Lecture 13
Starting Out with C++ Early Objects Seventh Edition by Tony Gaddis, Judy Walters, and Godfrey Muganda Modified for use by MSU Dept. of Computer Science.
Chapter 9 slide 1 Introduction to Search Algorithms Search: locate an item in a list (array, vector, table, etc.) of information Two algorithms (methods):
Searching & Sorting Programming 2. Searching Searching is the process of determining if a target item is present in a list of items, and locating it A.
Copyright © 2009 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Chapter 9 Searching & Sorting.
1 Searching and Sorting Searching algorithms with simple arrays Sorting algorithms with simple arrays –Selection Sort –Insertion Sort –Bubble Sort –Quick.
Chapter 7: Arrays. Outline Array Definition Access Array Array Initialization Array Processing 2D Array.
1 Principles of Computer Science I Honors Section Note Set 5 CSE 1341.
1 Chapter 13-2 Applied Arrays: Lists and Strings Dale/Weems.
Course Code #IDCGRF001-A 5.1: Searching and sorting concepts Programming Techniques.
Java Programming: From Problem Analysis to Program Design, 4e Chapter 14 Searching and Sorting.
Copyright © 2011 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Starting Out with C++ Early Objects Seventh Edition by Tony Gaddis, Judy.
 Introduction to Search Algorithms  Linear Search  Binary Search 9-2.
Copyright © 2015, 2012, 2009 Pearson Education, Inc., Publishing as Addison-Wesley All rights reserved. Chapter 8: Searching and Sorting Arrays.
Starting Out with C++, 3 rd Edition 1 Sorting Arrays.
1 compares each element of the array with the search key. works well for small arrays or for unsorted arrays works for any table slow can put more commonly.
Searching Arrays Linear search Binary search small arrays
Searching and Sorting Searching algorithms with simple arrays
Searching and Sorting Arrays
Chapter 9: Sorting and Searching Arrays
Alternate Version of STARTING OUT WITH C++ 4th Edition
Definition of Computer Science
Lecture 14 Searching and Sorting Richard Gesick.
Introduction to Search Algorithms
Chapter 9: Searching, Sorting, and Algorithm Analysis
Chapter 9: Searching, Sorting, and Algorithm Analysis
Sorting Algorithms.
Algorithm Efficiency and Sorting
Introduction to Search Algorithms
Lecture 11 Searching and Sorting Richard Gesick.
Searching and Sorting Arrays
Standard Version of Starting Out with C++, 4th Edition
Chapter 8 – Searching and Sorting Arrays
Searching and Sorting 1-D Arrays
Search,Sort,Recursion.
Principles of Computing – UFCFA3-30-1
Searching and Sorting Arrays
Algorithms Step-by-step instructions that tell a computing agent how to solve some problem using only finite resources Resources Memory CPU cycles Time/Space.
Search,Sort,Recursion.
Algorithms Step-by-step instructions that tell a computing agent how to solve some problem using only finite resources Resources Memory CPU cycles Time/Space.
Searching and Sorting Arrays
Introduction to Sorting Algorithms
Principles of Computing – UFCFA3-30-1
Presentation transcript:

Searching and Sorting Arrays Chapter Searching and Sorting Arrays 8 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Introduction to Search Algorithms 8.1 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Introduction to Search Algorithms Search: locate an item in a list of information Two algorithms we will examine: Linear search Binary search

Linear Search Also called the sequential search Starting at the first element, this algorithm sequentially steps through an array examining each element until it locates the value it is searching for.

Sequential Search of a student database . name EID major credit hrs. John Smith Paula Jones Led Belly Chuck Bin JS456 PJ123 LEB900 CB1235 physics history music math 36 125 72 89 1 2 n 3 algorithm to search database by EID : 1. ask user to enter EID to search for 2. set i to 1 3. set found to ‘no’ 4. while i <= n and found = ‘no’ do 5. if EID = EIDi 6. then set found to ‘yes’ else 6. increment i by 1 7. if found = ‘no’ then print “no such student” else < student found at array index i > 6

A Linear Search Function int searchList(int list[], int numElems, int value) { int index = 0; // Used as a subscript to search array int position = -1; // To record position of search value bool found = false; // Flag to indicate if value was found while (index < numElems && !found) { if (list[index] == value) // If the value is found { found = true; // Set the flag position = index; // Record the value's subscript } index++; // Go to the next element } return position; // Return the position, or -1 }

Linear Search - Tradeoffs Benefits: Easy algorithm to understand Array can be in any order Disadvantages: Inefficient (slow): for array of n elements has performance equivalent to O(n)

Binary Search Requires array elements to be in order Divides the array into three sections: middle element elements on one side of the middle element elements on the other side of the middle element If the middle element is the correct value, done. Otherwise, go to step 1. using only the half of the array that may contain the correct value. Continue steps 1. and 2. until either the value is found or there are no more elements to examine

The binary search algorithm assuming that the entries in student are sorted in increasing order, 1. ask user to input studentNum to search for 2. set beginning to 1 3. set end to n 4. set found to ‘no’ 5. while beginning <= end and found = ‘no’ 6. set middle to (beginning + end) / 2 {round down to nearest integer} 7. if studentNum = studentmiddle then set found to ‘yes’ 8. if studentNum < studentmiddle then set end to middle - 1 9. if studentNum > studentmiddle then set beginning to middle + 1 10.if found = ‘no’ then print “no such student” else <studentNum found at array index middle> 10

A Binary Search Function int binarySearch(int array[], int numElems, int value) { int first = 0, // First array element last = numElems - 1, // Last array element middle, // Mid point of search position = -1; // Position of search value bool found = false; // Flag while (!found && first <= last) { middle = (first + last) / 2; // Calculate mid point if (array[middle] == value) // If value is found at mid { found = true; position = middle; } else if (array[middle] > value) // If value is in lower half last = middle - 1; else first = middle + 1; // If value is in upper half } return position; }

Binary Search - Tradeoffs Benefits: Much more efficient than linear search. For array of n elements, the running time is O(log(n)) Disadvantages: Requires that array elements be sorted

Introduction to Sorting Algorithms 8.3 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Introduction to Sorting Algorithms Sort: arrange values into an order: Alphabetical Ascending numeric Descending numeric Two algorithms considered here: Bubble sort Selection sort

Bubble Sort Concept: Compare 1st two elements If out of order, exchange them to put in order Move down one element, compare 2nd and 3rd elements, exchange if necessary. Continue until end of array. Pass through array again, exchanging as necessary Repeat until pass made with no exchanges

Example – First Pass Array numlist3 contains: 17 23 5 11 compare values 17 and 23 – in correct order, so no exchange compare values 23 and 11 – not in correct order, so exchange them compare values 23 and 5 – not in correct order, so exchange them

Example – Second Pass After first pass, array numlist3 contains: 17 5 11 23 compare values 17 and 5 – not in correct order, so exchange them compare values 17 and 23 – in correct order, so no exchange compare values 17 and 11 – not in correct order, so exchange them

Example – Third Pass After second pass, array numlist3 contains: 5 11 17 23 compare values 5 and 11 – in correct order, so no exchange compare values 17 and 23 – in correct order, so no exchange compare values 11 and 17 – in correct order, so no exchange No exchanges, so array is in order

Bubble sort illustrated with dance https://www.youtube.com/watch?v=lyZQPjUT5B4

A Bubble Sort Function – From Program 8-4

Bubble Sort - Tradeoffs Benefit: Easy to understand and implement Disadvantage: Inefficient: slow for large arrays

Selection Sort Concept for sort in ascending order: Locate smallest element in array. Exchange it with element in position 0 Locate next smallest element in array. Exchange it with element in position 1. Continue until all elements are arranged in order

Selection Sort - Example Array numlist contains: Smallest element is 2. Exchange 2 with element in 1st position in array: 11 2 29 3 2 11 29 3

Example (Continued) Next smallest element is 3. Exchange 3 with element in 2nd position in array: Next smallest element is 11. Exchange 11 with element in 3rd position in array: 2 3 29 11 2 3 11 29

Selection sort illustrated with dance https://www.youtube.com/watch?v=Ns4TPTC8whw

Selection sort illustrated with dance https://www.youtube.com/watch?v=6nDMgr0-Yyo

A Selection Sort Function – From Program 8-5 35 void selectionSort(int array[], int size) 36 { 37 int startScan, minIndex, minValue; 38 39 for (startScan = 0; startScan < (size - 1); startScan++) 40 { 41 minIndex = startScan; 42 minValue = array[startScan]; 43 for(int index = startScan + 1; index < size; index++) 44 { 45 if (array[index] < minValue) 46 { 47 minValue = array[index]; 48 minIndex = index; 49 } 50 } 51 array[minIndex] = array[startScan]; 52 array[startScan] = minValue; 53 } 54 }

Selection Sort - Tradeoffs Benefit: More efficient than Bubble Sort, since fewer exchanges Disadvantage: May not be as easy as Bubble Sort to understand

Sorting and Searching Vectors 8.5 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Sorting and Searching Vectors Sorting and searching algorithms can be applied to vectors as well as arrays Need slight modifications to functions to use vector arguments: vector <type> & used in prototype No need to indicate vector size – functions can use size member function to calculate name.push_back(value) – add the value to the vector name.pop_back(value) – deletes the last value in the vector