DaniWeb Forum Index > Software Development > C++

C++ RSS

help with sorting arrays from hightest to lowest

Please support our C++ advertiser: Intel Parallel Studio Home

•

Join Date: Nov 2006

Posts: 28

Reputation: joelw is an unknown quantity at this point

Solved Threads: 0

joelw

Offline

Light Poster

help with sorting arrays from hightest to lowest

Nov 16th, 2006

im getting an error cannot convert 'int' to 'double' for argument '1' to 'double sort Array(double'.int)' while trying to debug code
what does that mean here is another copy of my code now.

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
#include <iostream>
#include <iomanip>
 
using namespace std;
 
// Function prototypes
double sumArray(double[], int);
double getHighest(double[], int);
double getLowest(double[], int);
double sortArray(double [], int);
double showArray(double [], int);
 
int main()
{
    const int MONTHS = 12;
    int values[MONTHS] = {12, 11, 10, 9, 8, 7, 6,
    5, 4, 3, 2, 1};
 
    double amount[MONTHS] = {12, 34, 3, 6, 5, 7, 4, 44, 43, 40, 41, 9 };
    double total,                    // To hold the total rainfall
           average,                  // To hold the average rainfall
           highest,                  // To hold the highest rainfall amount
           lowest;                   // To hold the lowest rainfall amount
 
 
    cout << "Enter the rainfall for each month.\n";
    for (int count = 0; count < MONTHS; count++)
    {
        cout << "Month " << (count + 1) << ": ";
        cin >> amount[count];
    }
 
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
 
    // Calculate the average rainfall
    average = total / MONTHS;
 
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
 
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
 
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(values, MONTHS);
    showArray(values, MONTHS);
	return 0;
}
 
 
 
//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************
 
double sumArray(double array[], int size)
{
  double total = 0;
 
  for (int count = 0; count < size; count++)
    total += array[count];
  return total;
}
 
 
//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************
 
double getHighest(double array[], int size)
{
       double highest;
 
       highest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] > highest)
              highest = array[count];
       }
       return highest;
}
 
//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************
 
double getLowest(double array[], int size)
{
       double lowest;
 
       lowest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] < lowest)
              lowest = array[count];
       }
       return lowest;
}
 
 
 
//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order buble sort on         *
// array. elems is the number of elements in the array.             *
//*******************************************************************
 
void sortArray(int array[], int elems)
{
  bool swap;
  int temp;
 
  do
  {
    swap = false;
    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 = true;
      }
    }
  } while (swap);
}
 
 
 
 
//********************************************************************
// 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;
}
#include <iostream>
#include <iomanip>

using namespace std;

// Function prototypes
double sumArray(double[], int);
double getHighest(double[], int);
double getLowest(double[], int);
double sortArray(double [], int);
double showArray(double [], int);

int main()
{
    const int MONTHS = 12;
    int values[MONTHS] = {12, 11, 10, 9, 8, 7, 6,
    5, 4, 3, 2, 1};

    double amount[MONTHS] = {12, 34, 3, 6, 5, 7, 4, 44, 43, 40, 41, 9 };
    double total,                    // To hold the total rainfall
           average,                  // To hold the average rainfall
           highest,                  // To hold the highest rainfall amount
           lowest;                   // To hold the lowest rainfall amount
    
        
    cout << "Enter the rainfall for each month.\n";
    for (int count = 0; count < MONTHS; count++)
    {
        cout << "Month " << (count + 1) << ": ";
        cin >> amount[count];
    }
    
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
    
    // Calculate the average rainfall
    average = total / MONTHS;
    
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
    
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
    
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(values, MONTHS);
    showArray(values, MONTHS);
	return 0;
}



//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************

double sumArray(double array[], int size)
{
  double total = 0;

  for (int count = 0; count < size; count++)
    total += array[count];
  return total;
}


//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************

double getHighest(double array[], int size)
{
       double highest;
       
       highest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] > highest)
              highest = array[count];
       }
       return highest;
}

//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************

double getLowest(double array[], int size)
{
       double lowest;
       
       lowest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] < lowest)
              lowest = array[count];
       }
       return lowest;
}



//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order buble sort on         *
// array. elems is the number of elements in the array.             *
//*******************************************************************

void sortArray(int array[], int elems)
{
  bool swap;
  int temp;

  do
  {
    swap = false;
    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 = true;
      }
    }
  } while (swap);
}




//********************************************************************
// 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;
}

•

Join Date: Aug 2005

Posts: 15,362

Reputation: Ancient Dragon has a reputation beyond repute

Solved Threads: 1464

Ancient Dragon Ancient Dragon is offline

Offline

Still Learning

Re: help with sorting arrays from hightest to lowest

Nov 16th, 2006

those functions sort double arrays, not int arrays. Either change your int arrays to double, or change the functions to sort int arrays. The two can not be mixed.

>>double sortArray(double [], int);
this is the wrong prototype. Actual function does not have those parameters.

Last edited by Ancient Dragon; Nov 16th, 2006 at 8:34 am.

Don't PM me with questions -- you might get a nasty PM in response. If you have a question then post it in one of the forums.

•

Join Date: Nov 2006

Posts: 28

Reputation: joelw is an unknown quantity at this point

Solved Threads: 0

joelw

Offline

Light Poster

Re: help with sorting arrays from hightest to lowest

Nov 16th, 2006

ok i changed that to match and now its giving me some more issues heres my code

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
#include <iostream>
#include <iomanip>
using namespace std;
// Function prototypes
double sumArray(double array[], int size);
double getHighest(double array[], int size);
double getLowest(double array[], int size);
double sortArray(double array[], int size);
double showArray(double array[], int size);
int main()
{
    const int MONTHS = 12;
    int values[MONTHS] = {12, 11, 10, 9, 8, 7, 6,
    5, 4, 3, 2, 1};
    double amount[MONTHS] = {12, 34, 3, 6, 5, 7, 4, 44, 43, 40, 41, 9 };
    double total,                    // To hold the total rainfall
           average,                  // To hold the average rainfall
           highest,                  // To hold the highest rainfall amount
           lowest;                   // To hold the lowest rainfall amount
 
 
    cout << "Enter the rainfall for each month.\n";
    for (int count = 0; count < MONTHS; count++)
    {
        cout << "Month " << (count + 1) << ": ";
        cin >> amount[count];
    }
 
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
 
    // Calculate the average rainfall
    average = total / MONTHS;
 
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
 
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
 
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(amount, MONTHS);
    showArray(amount, MONTHS);
 return 0;
}
 
//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************
double sumArray(double array[], int size)
{
  double total = 0;
  for (int count = 0; count < size; count++)
    total += array[count];
  return total;
}
 
//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************
double getHighest(double array[], int size)
{
       double highest;
 
       highest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] > highest)
              highest = array[count];
       }
       return highest;
}
//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************
double getLowest(double array[], int size)
{
       double lowest;
 
       lowest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] < lowest)
              lowest = array[count];
       }
       return lowest;
}
 
//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order buble sort on         *
// array. elems is the number of elements in the array.             *
//*******************************************************************
double sortArray(double array[], int elems)
{
  bool swap;
  int temp;
  do
  {
    swap = false;
    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 = true;
      }
    }
  } while (swap);
}
 
 
//********************************************************************
// Definition of function showArray.                                 *
// This function displays the contents of array. elems is the        *
// number of elements.                                               *
//********************************************************************
double showArray(double array[], int elems)
{
  for (int count = 0; count < elems; count++)
    cout << array[count] << " ";
  cout << endl;
}
#include <iostream>
#include <iomanip>
using namespace std;
// Function prototypes
double sumArray(double array[], int size);
double getHighest(double array[], int size);
double getLowest(double array[], int size);
double sortArray(double array[], int size);
double showArray(double array[], int size);
int main()
{
    const int MONTHS = 12;
    int values[MONTHS] = {12, 11, 10, 9, 8, 7, 6,
    5, 4, 3, 2, 1};
    double amount[MONTHS] = {12, 34, 3, 6, 5, 7, 4, 44, 43, 40, 41, 9 };
    double total,                    // To hold the total rainfall
           average,                  // To hold the average rainfall
           highest,                  // To hold the highest rainfall amount
           lowest;                   // To hold the lowest rainfall amount
    
        
    cout << "Enter the rainfall for each month.\n";
    for (int count = 0; count < MONTHS; count++)
    {
        cout << "Month " << (count + 1) << ": ";
        cin >> amount[count];
    }
    
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
    
    // Calculate the average rainfall
    average = total / MONTHS;
    
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
    
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
    
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(amount, MONTHS);
    showArray(amount, MONTHS);
 return 0;
}
 
//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************
double sumArray(double array[], int size)
{
  double total = 0;
  for (int count = 0; count < size; count++)
    total += array[count];
  return total;
}

//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************
double getHighest(double array[], int size)
{
       double highest;
       
       highest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] > highest)
              highest = array[count];
       }
       return highest;
}
//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************
double getLowest(double array[], int size)
{
       double lowest;
       
       lowest = array[0];
       for (int count = 1; count < size; count++)
       {
           if (array[count] < lowest)
              lowest = array[count];
       }
       return lowest;
}
 
//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order buble sort on         *
// array. elems is the number of elements in the array.             *
//*******************************************************************
double sortArray(double array[], int elems)
{
  bool swap;
  int temp;
  do
  {
    swap = false;
    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 = true;
      }
    }
  } while (swap);
}
 

//********************************************************************
// Definition of function showArray.                                 *
// This function displays the contents of array. elems is the        *
// number of elements.                                               *
//********************************************************************
double showArray(double array[], int elems)
{
  for (int count = 0; count < elems; count++)
    cout << array[count] << " ";
  cout << endl;
}

•

Join Date: Aug 2005

Posts: 5,264

Reputation: iamthwee is a splendid one to behold

Solved Threads: 377

iamthwee

Offline

Posting Expert

Re: help with sorting arrays from hightest to lowest

Nov 16th, 2006

That's nice, have you heard of debugging and finding out what might be wrong yourself?

*Voted best profile in the world*

•

Join Date: Aug 2005

Posts: 15,362

Reputation: Ancient Dragon has a reputation beyond repute

Solved Threads: 1464

Ancient Dragon Ancient Dragon is offline

Offline

Still Learning

Re: help with sorting arrays from hightest to lowest

Nov 16th, 2006

>>ok i changed that to match and now its giving me some more issues heres my code

what where the errors? did you make any attempt to fix them?

Don't PM me with questions -- you might get a nasty PM in response. If you have a question then post it in one of the forums.

•

Join Date: Nov 2006

Posts: 28

Reputation: joelw is an unknown quantity at this point

Solved Threads: 0

joelw

Offline

Light Poster

Re: help with sorting arrays from hightest to lowest

Nov 17th, 2006

yeah i changed showValue and sortValue back to a void and changed the int to doubles i guess thats why im getting the error message:

invalid types `double*[double]' for array subscript

•

Join Date: Oct 2006

Posts: 57

Reputation: may4life is an unknown quantity at this point

Solved Threads: 2

may4life

Offline

Junior Poster in Training

Re: help with sorting arrays from hightest to lowest

Nov 17th, 2006

Here's a working solution. Ok what I did is:
1. Changed the sort algorithm from bubble to selection sort, passing the array in by reference.
2. Changed both sortArray and ShowArray functions to void, the needn't be double, they dont return anything.
3. Changed the count variable from 0 to 1 and used count instead of (count+1) in the loop at the beginning.
4. Changed the spacing and some minor things you prob wont even notice.
Study this code and try to understand it. It might not be exactly what you're looking for but it works fine. If you want, change back the sorting algorithm you had but that's up to you. Hope this helps, byee

 Help with Code Tags 
 C++ Syntax (Toggle Plain Text) 
#include <iostream>
#include <iomanip>
 
using namespace std;
 
// Function prototypes
double sumArray(double array[], int size);
double getHighest(double array[], int size);
double getLowest(double array[], int size);
void sortArray(double (&array)[12], int size); // send array by reference
void showArray(double array[], int size);
 
int main()
{
    const int MONTHS = 12;
    int values[MONTHS]      = {12,11,10,9,8,7,6, 5, 4, 3, 2,1 };
    double amount[MONTHS] = {12,34,3, 6,5,7,4,44,43,40,41,9 };
 
    double total;    // To hold the total rainfall
    double average;    // To hold the average rainfall
    double highest;    // To hold the highest rainfall amount
    double lowest;    // To hold the lowest rainfall amount
 
    cout << "Enter the rainfall for each month.\n";
    for (int count=1; count<=MONTHS; count++)
    {
        cout << "Month " << count << ": ";
        cin >> amount[count];
    }
 
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
 
    // Calculate the average rainfall
    average = total / MONTHS;
 
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
 
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
 
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(amount, MONTHS);
    showArray(amount, MONTHS);
 
 return 0;
}
 
//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************
double sumArray(double array[], int size)
{
    double total = 0;
    for (int count = 0; count < size; count++)
        total += array[count];
    return total;
}
 
//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************
double getHighest(double array[], int size)
{
    double highest;
 
    highest = array[0];
    for (int count = 1; count < size; count++)
    {
        if (array[count] > highest)
            highest = array[count];
    }
    return highest;
}
//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************
double getLowest(double array[], int size)
{
    double lowest;
 
    lowest = array[0];
    for (int count = 1; count < size; count++)
    {
        if (array[count] < lowest)
            lowest = array[count];
    }
    return lowest;
}
 
//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order selection sort on     *
// array. elems is the number of elements in the array.             *
//*******************************************************************
void sortArray(double (&array)[12], int elems)
{
    int first, temp;
 
    for (int i=elems-1; i>0; i--)
    {
        first = 0;
        for (int j=1; j<=i; j++)
        {
            if (array[j] < array[first])
                first = j;
        }
        temp = array[first];
        array[first] = array[i];
        array[i] = temp;
    }
}
 
 
//********************************************************************
// Definition of function showArray.                                 *
// This function displays the contents of array. elems is the        *
// number of elements.                                               *
//********************************************************************
void showArray(double array[], int elems)
{
    for (int count = 0; count < elems; count++)
        cout << array[count] << " ";
    cout << endl;
}
#include <iostream>
#include <iomanip>

using namespace std;

// Function prototypes
double sumArray(double array[], int size);
double getHighest(double array[], int size);
double getLowest(double array[], int size);
void sortArray(double (&array)[12], int size); // send array by reference
void showArray(double array[], int size);

int main()
{
    const int MONTHS = 12;
    int values[MONTHS]      = {12,11,10,9,8,7,6, 5, 4, 3, 2,1 };
    double amount[MONTHS] = {12,34,3, 6,5,7,4,44,43,40,41,9 };

    double total;    // To hold the total rainfall
    double average;    // To hold the average rainfall
    double highest;    // To hold the highest rainfall amount
    double lowest;    // To hold the lowest rainfall amount
    
    cout << "Enter the rainfall for each month.\n";
    for (int count=1; count<=MONTHS; count++)
    {
        cout << "Month " << count << ": ";
        cin >> amount[count];
    }
    
    // Get the total monthly rainfall
    total = sumArray(amount, MONTHS);
    
    // Calculate the average rainfall
    average = total / MONTHS;
    
    // Find the highest monthly rainfall
    highest = getHighest(amount, MONTHS);
    
    // Find the lowest monthly rainfall
    lowest = getLowest(amount, MONTHS);
    
    // Display the results
    cout << fixed << showpoint << setprecision(2);
    cout << "The total monthly rainfall is "  << total << " inches" << endl;
    cout << "The average monthly rainfall is "  << average << " inches" << endl;
    cout << "The highest monthly rainfall is "  << highest << " inches" << endl;
    cout << "The lowest monthly rainfall is "  << lowest << " inches " << endl;          
    cout << "The monthly rainfall in descending order:\n";
    sortArray(amount, MONTHS);
    showArray(amount, MONTHS);

 return 0;
}
 
//******************************************************************
// Definition of sumArray                                          *
// This function accepts a double array and its size               *
// as arguments. The sum of the array's elements                   *
// is returned as an double.                                       *
//******************************************************************
double sumArray(double array[], int size)
{
    double total = 0;
    for (int count = 0; count < size; count++)
        total += array[count];
    return total;
}

//******************************************************************
// Definition of getHighest                                        *
// This function accepts a double array and its size               *
// as arguments. The highest value in the array is                 *
// returned as an double.                                          *
//******************************************************************
double getHighest(double array[], int size)
{
    double highest;
       
    highest = array[0];
    for (int count = 1; count < size; count++)
    {
        if (array[count] > highest)
            highest = array[count];
    }
    return highest;
}
//*******************************************************************
// Definition of getLowest                                          *
// This function accepts a double array and its size                *
// as arguments. The lowest value in the array is                   *
// returned as an double                                            *
//*******************************************************************
double getLowest(double array[], int size)
{
    double lowest;
       
    lowest = array[0];
    for (int count = 1; count < size; count++)
    {
        if (array[count] < lowest)
            lowest = array[count];
    }
    return lowest;
}
 
//*******************************************************************
// Definition of function sortArray                                 *
// This function performs an descending order selection sort on     *
// array. elems is the number of elements in the array.             *
//*******************************************************************
void sortArray(double (&array)[12], int elems)
{
    int first, temp;

    for (int i=elems-1; i>0; i--)
    {
        first = 0;
        for (int j=1; j<=i; j++)
        {
            if (array[j] < array[first])
                first = j;
        }
        temp = array[first];
        array[first] = array[i];
        array[i] = temp;
    }
}
 

//********************************************************************
// Definition of function showArray.                                 *
// This function displays the contents of array. elems is the        *
// number of elements.                                               *
//********************************************************************
void showArray(double array[], int elems)
{
    for (int count = 0; count < elems; count++)
        cout << array[count] << " ";
    cout << endl;
}