How can I add bubble sort to this code? // This program produces a sales report
Question:
How can I add bubble sort to this code?
// This program produces a sales report for DLC, Inc.
#include
#include
using namespace std;
// Function prototypes
void calcSales(const int [], const double [], double [], int);
void showOrder(const double [], const int [], int);
void dualSort(int [], double [], int);
void showTotals(const double [], const int [], int);
// NUM_PRODS is the number of products produced.
const int NUM_PRODS = 9;
int main()
{
// Array with product ID numbers
int id[NUM_PRODS] = {914, 915, 916, 917, 918, 919, 920,
921, 922};
// Array with number of units sold for each product
int units[NUM_PRODS] = {842, 416, 127, 514, 437, 269, 97,
492, 212};
// Array with product prices
double prices[NUM_PRODS] = {12.95, 14.95, 18.95, 16.95, 21.95,
31.95, 14.95, 14.95, 16.95};
// Array to hold the computed sales amounts
double sales[NUM_PRODS];
// Calculate each product's sales.
calcSales(units, prices, sales, NUM_PRODS);
// Sort the elements in the sales array in descending
// order and shuffle the ID numbers in the id array to
// keep them in parallel.
dualSort(id, sales, NUM_PRODS);
// Set the numeric output formatting.
cout << setprecision(2) << fixed << showpoint;
// Display the products and sales amounts.
showOrder(sales, id, NUM_PRODS);
// Display total units sold and total sales.
showTotals(sales, units, NUM_PRODS);
return 0;
} //end main
//****************************************************************
// Definition of calcSales. Accepts units, prices, and sales *
// arrays as arguments. The size of these arrays is passed *
// into the num 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 array. *
//****************************************************************
void calcSales(const int units[], const double prices[], double sales[], int num)
{
for (int index = 0; index < num; index++)
sales[index] = units[index] * prices[index];
}//end calcSales
//***************************************************************
// Definition of function dualSort. Accepts id and sales arrays *
// as arguments. The size of these arrays is passed into size. *
// This function performs a descending order selection sort on *
// the sales array. The elements of the id array are exchanged *
// identically as those of the sales array. size is the number *
// of elements in each array. *
//***************************************************************
void dualSort(int id[], double sales[], int size)
{
int startScan, maxIndex, tempid;
double maxValue;
for (startScan = 0; startScan < (size - 1); startScan++)
{
maxIndex = startScan;
maxValue = sales[startScan];
tempid = id[startScan];
for(int index = startScan + 1; index < size; index++)
{
if (sales[index] > maxValue)
{
maxValue = sales [index];
tempid = id[index];
maxIndex = index;
}
}
sales[maxIndex] = sales[startScan];
swap(sales[maxIndex], sales[startScan]);
swap(id[maxIndex], id[startScan]);
}
}
//******************************************************
// The swap function swaps doubles a and b in memory. *
//******************************************************
void swap(double &a, double &b)
{
double temp = a;
a = b;
b = temp;
}
//******************************************************
// The swap function swaps ints a and b in memory. *
//******************************************************
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
//*****************************************************************
// Definition of showOrder function. Accepts sales and id arrays *
// as arguments. The size of these arrays is passed into num. *
// The function first displays a heading, then the sorted list *
// of product numbers and sales. *
//*****************************************************************
void showOrder(const double sales[], const int id[], int num)
{
cout << "Product Number\tSales\n";
cout << "----------------------------------\n";
for (int index = 0; index < num; index++)
{
cout << id[index] << "\t\t$";
cout << setw(8) << sales[index] << endl;
}
cout << endl;
}
//******************************************************************
// Definition of showTotals function. Accepts sales and id arrays *
// as arguments. The size of these arrays is passed into num. *
// The function first calculates the total units (of all *
// products) sold and the total sales. It then displays these *
// amounts. *
//******************************************************************
void showTotals(const double sales[], const int units[], int num)
{
int totalUnits = 0;
double totalSales = 0.0;
for (int index = 0; index < num; index++)
{
totalUnits += units[index];
totalSales += sales[index];
}
cout << "Total units Sold: " << totalUnits << endl;
cout << "Total sales: $" << totalSales << endl;
}
// perform bubble sort
void bubbleSort(int array[], int size) {
// loop to access each array element
for (int step = 0; step < size; ++step) {
// loop to compare array elements
for (int i = 0; i < size - step; ++i) {
// compare two adjacent elements
// change > to < to sort in descending order
if (array[i] > array[i + 1]) {
// swapping elements if elements
// are not in the intended order
int temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
}
// print array
void printArray(int array[], int size) {
for (int i = 0; i < size; ++i) {
cout << " " << array[i];
}
cout << "\n";
}