Chapter 8 - Searching and Sorting Arrays: Starting Out With C++, 3 Edition

Chapter 8 – Searching and Sorting
Arrays
1
Starting Out with C++, 3rd Edition
8.1 Introduction to Search Algorithms
• A search algorithm is a method of locating a

specific item of information in a larger
collection of data. This section discusses
two algorithms for searching the contents of
an array.
2
The Linear Search
• This is a very simple algorithm.

• It uses a loop to sequentially step through
an array, starting with the first element.
• It compares each element with the value
being searched for and stops when that
value is found or the end of the array is
reached.
3
Program 8-1
// This program demonstrates the searchList function, which
// performs a linear search on an integer array.
#include <iostream.h>
// Function prototype
int searchList(int [], int, int);
const int arrSize = 5;
void main(void)
{
int tests[arrSize] = {87, 75, 98, 100, 82};
int results;
4
Program continues
results = searchList(tests, arrSize, 100);
if (results == -1)
cout << "You did not earn 100 points on any test\n";
else
{
cout << "You earned 100 points on test ";
cout << (results + 1) << endl;
}
}
5
Program continues
// The searchList function performs a linear search on an
// integer array. The array list, which has a maximum of numElems
// elements, is searched for the number stored in value. If the
// number is found, its array subscript is returned. Otherwise,
// -1 is returned indicating the value was not in the array.
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 the value was found
while (index < numElelments && !found)
{
if (list[count] == value)
{
found = true;
position = index;
}
index++;
}
return position;
}
6
Program Output
You earned 100 points on test 4
7
Efficiency of the Linear Search
• The advantage is its simplicity.

– It is easy to understand
– Easy to implement
– Does not require the array to be in order
• The disadvantage is its inefficiency
– If there are 20,000 items in the array and what
you are looking for is in the 19,999th element,
you need to search through the entire list.
8
Binary Search
• The binary search is much more efficient than the

linear search.
• It requires the list to be in order.
• The algorithm starts searching with the middle
element.
– If the item is less than the middle element, it starts over searching
the first half of the list.
– If the item is greater than the middle element, the search starts
over starting with the middle element in the second half of the list.
– It then continues halving the list until the item is found.
9
Program 8-2
// This program demonstrates the binarySearch function, which
// performs a binary search on an integer array.
// Function prototype
int binarySearch(int [], int, int);
const int arrSize = 20;
void main(void)
{
int tests[arrSize] = {101, 142, 147, 189, 199, 207, 222,
234, 289, 296, 310, 319, 388, 394,
417, 429, 447, 521, 536, 600};
10
Program continues
int results, empID;
cout << "Enter the Employee ID you wish to search for: ";
cin >> empID;
results = binarySearch(tests, arrSize, empID);
if (results == -1)
cout << "That number does not exist in the array.\n";
else
{
cout << "That ID is found at element " << results;
cout << " in the array\n";
}
}
11
Program continues
// The binarySearch function performs a binary search on an integer array. Array,
// which has a maximum of numElems elements, is searched for the number
// stored in value. If the number is found, its array subscript is returned.
// Otherwise, -1 is returned indicating the value was not in the array.
int binarySearch(int array[], int numelems, int value)

{
int first = 0, last = numelems - 1, middle, position = -1;
bool found = false;
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;
}
12
Program Output with Example Input
Enter the Employee ID you wish to search for: 199

That ID is found at element 4 in the array.
13
Efficiency of the Binary Search
• Much more efficient than the linear search.
14
8.3 Focus on Software Engineering:
Introduction to Sorting Algorithms
• Sorting algorithms are used to arrange
random data into some order
15
The Bubble Sort
• An easy way to arrange data in ascending or
descending order.
• Pseudocode:
Do
Set count variable to 0
For count is set to each subscript in Array from 0 to the next-to-last
subscript
If array[count] is greater than array[count+1]
swap them
set swap flag to true
end if
End for
While any elements have been swapped.
16
Program 8-4
// This program uses the bubble sort algorithm to sort an
// array in ascending order.
// Function prototypes
void sortArray(int [], int);
void showArray(int [], int);
void main(void)
{
int values[6] = {7, 2, 3, 8, 9, 1};
cout << "The unsorted values are:\n";
showArray(values, 6);
sortArray(values, 6);
cout << "The sorted values are:\n";
}
17
Program continues
// Definition of function sortArray. This function performs an ascending
// order bubble sort on Array. elems is the number of elements in the array.
void sortArray(int array[], int elems)

{
int swap, temp;
do
{
swap = 0;
for (int count = 0; count < (elems - 1); count++)
{
if (array[count] > array[count + 1])
{
temp = array[count];
array[count] = array[count + 1];
array[count + 1] = temp;
swap = 1;
}
}
} while (swap != 0);
}
18
Program continues
// Definition of function showArray.
// This function displays the contents of array. elems is the
// number of elements.
void showArray(int array[], int elems)

{
for (int count = 0; count < elems; count++)
cout << array[count] << " ";
cout << endl;
}
19
Program Output
The unsorted values are:

723891
The sorted values are:
123789
20
The Selection Sort
• The bubble sort is inefficient for large arrays

because items only move by one element at a time.
• The selection sort moves items immediately to
their final position in the array so it makes fewer
exchanges.
21
Selection Sort Pseudocode:
For Start is set to each subscript in Array from 0 through the next-to-last subscript
Set Index variable to Start
Set minIndex variable to Start
Set minValue variable to array[Start]
For Index is set to each subscript in Array from Start+1 through the next-to-last
subscript
If array[Index] is less than minValue
Set minValue to array[Index]
Set minIndex to Index
End if
Increment Index
End For
Set array[minIndex] to array[Start]
Set array[Start] to minValue
End For
22
Program 8-5
// This program uses the selection sort algorithm to sort an
// array in ascending order.
void selectionSort(int [], int);
void showArray(int [], int);
void main(void)
{
int values[6] = {5, 7, 2, 8, 9, 1};
cout << "The unsorted values are\n";

selectionSort(values, 6);
cout << "The sorted values are\n";
}
23
Program continues
// Definition of function selectionSort. This function performs an
// ascending order selection sort on Array. elems is the number of
// elements in the array.
void selectionSort(int array[], int elems)

{
int startScan, minIndex, minValue;
for (startScan = 0; startScan < (elems - 1); startScan++)
{ minIndex = startScan;
minValue = array[startScan];
for(int index = startScan + 1; index < elems; index++)
{ if (array[index] < minValue)
{
minValue = array[index];
minIndex = index;
}
}
array[minIndex] = array[startScan];
array[startScan] = minValue;
}
}
24
Program continues
// Definition of function showArray.
// This function displays the contents of Array. elems is the
// number of elements.
void showArray(int array[], int elems)

{
for (int count = 0; count < elems; count++)
cout << array[count] << " ";
cout << endl;
}
25
Program Output
The unsorted values are

572891
The sorted values are
125789
26
8.5 Sorting and Searching vectors
(Continued from Section 7.13)
• The sorting and searching algorithms

presented in this chapter may also be used
with vectors.
27
Program 8-7
// This program produces a sales report for the Demetris
// Leadership Center. This version of the program uses
// STL vectors instead of arrays.

#include <iomanip.h>
#include <vector> // Needed to declare vectors
using namespace std; // vectors are in the std namespace
void initVectors(vector<int> &, vector<int> &, vector<float> &);
void calcSales(vector<int>, vector<float>, vector<float> &);
void showOrder(vector<float>, vector<int>);
void dualSort(vector<int> &, vector<float> &);
void showTotals(vector<float>, vector<int>);

void main(void)
{
vector<int> id;
vector<int> units;
vector<float> prices;
vector<float> sales;
28
Program 8-7 (continued)
// Must provide an initialization routine.
initVectors(id, units, prices);

// Calculate and sort the sales totals,
// and display the results.
calcSales(units, prices, sales);
dualSort(id, sales);
cout.precision(2);
cout.setf(ios::fixed | ios::showpoint);
showOrder(sales, id);
showTotals(sales, units);
}

//******************************************************************
// Definition of initVectors. Accepts id, units, and prices *
// vectors as reference arguments. This function initializes each *
// vector to a set of starting values. *
//******************************************************************

29
void initVectors(vector<int> &id, vector<int> &units,
vector<float> &prices)
{
// Initialize the id vector
for (int value = 914; value <= 922; value++)
id.push_back(value);

// Initialize the units vector
units.push_back(842);

30
// Initialize the prices vector
prices.push_back(12.95);
}

//****************************************************************
// Definition of calcSales. Accepts units, prices, and sales *
// vectors as arguments. The sales vector is passed into a *
// reference parameter. This function calculates each product's *
// sales by multiplying its units sold by each unit's price. The *
// result is stored in the sales vector. *
//****************************************************************
31
void calcSales(vector<int> units, vector<float> prices,
vector<float> &sales)
{
for (int index = 0; index < units.size(); index++)
sales.push_back(units[index] * prices[index]);
}

//****************************************************************
// Definition of function dualSort. Accepts id and sales vectors *
// as reference arguments. This function performs a descending *
// order selection sort on the sales vector. The elements of the *
// id vector are exchanged identically as those of the sales *
// vector. *
//****************************************************************

void dualSort(vector<int> &id, vector<float> &sales)
{
int startScan, maxIndex, tempid, elems;
float maxValue;

32
elems = id.size();
for (startScan = 0; startScan < (elems - 1); startScan++)
{
maxIndex = startScan;
maxValue = sales[startScan];
tempid = id[startScan];
for(int index = startScan + 1; index < elems; index++)
{
if (sales[index] > maxValue)
{
maxValue = sales[index];
tempid = id[index];
maxIndex = index;
}
}
sales[maxIndex] = sales[startScan];
id[maxIndex] = id[startScan];
sales[startScan] = maxValue;
id[startScan] = tempid;
}
}
33
//*****************************************************************
// Definition of showOrder function. Accepts sales and id vectors *
// as arguments. The function first displays a heading, then the *
// sorted list of product numbers and sales. *
//*****************************************************************

void showOrder(vector<float> sales, vector<int> id)
{
cout << "Product number\tsales\n";
cout << "----------------------------------\n";
for (int index = 0; index < id.size(); index++)
{
cout << id[index] << "\t\t$";
cout << setw(8) << sales[index] << endl;
}
cout << endl;
}
34
//*******************************************************************
// Definition of showTotals function. Accepts sales and id vectors *
// as arguments. The function first calculates the total units (of *
// all products) sold and the total sales. It then displays these *
// amounts. *
//*******************************************************************

void showTotals(vector<float> sales, vector<int> units)
{
int totalUnits = 0;
float totalSales = 0.0;

for (int index = 0; index < units.size(); index++)
{
totalUnits += units[index];
totalSales += sales[index];
}
cout << "Total units Sold: " << totalUnits << endl;
cout << "Total sales: $" << totalSales << endl;
}
35
Program Output

Product number sales
----------------------------------
914 $10903.90
918 $ 9592.15
917 $ 8712.30
919 $ 8594.55
921 $ 7355.40
915 $ 6219.20
922 $ 3593.40
916 $ 2406.65
920 $ 1450.15

Total units Sold: 3406
Total sales: $58827.70
36

Chapter 8 - Searching and Sorting Arrays: Starting Out With C++, 3 Edition

Uploaded by

Chapter 8 - Searching and Sorting Arrays: Starting Out With C++, 3 Edition

Uploaded by

Chapter 8 – Searching and Sorting

• A search algorithm is a method of locating a

• This is a very simple algorithm.

const int arrSize = 5;

int searchList(int list[], int numElems, int value)

You earned 100 points on test 4

• The advantage is its simplicity.

• The binary search is much more efficient than the

const int arrSize = 20;

int binarySearch(int array[], int numelems, int value)

Enter the Employee ID you wish to search for: 199

• Much more efficient than the linear search.

void sortArray(int array[], int elems)

void showArray(int array[], int elems)

The unsorted values are:

• The bubble sort is inefficient for large arrays

cout << "The unsorted values are\n";

void selectionSort(int array[], int elems)

void showArray(int array[], int elems)

The unsorted values are

• The sorting and searching algorithms

You might also like