//*************************************************************************
string readCreditFile(ifstream& inCreditData, string idNum[], string classLevel[], int& cnt)
{
	string studentId;					// stored value for the students ID number
	char ch;							// stored value for the students status
	int classesTaken;					// number of credits completed by student
	studentLevel num;					// the numerical value of the function studentClass;
	string title;						// stored value from the function studentClass
	bool arrayFull = false;			    // check to see if there is still space in the array idNum[]

	while(inCreditData >> studentId >> ch >> classesTaken && cnt <= MAX_ARRAY)
	{
		if (ch == 'U' && !arrayFull)
		{
			idNum[cnt] = studentId;				// store student ID into idNum array
			num = studentNum(classesTaken);	    // function to convert class taken to ordinal value
			title = studentTitle(num);			// function to convert ordinal value to string
			classLevel[cnt] = title;			// store string value of class level into array
			cnt++;
			if (cnt >= MAX_ARRAY)				// test to see if array is full
			{
				arrayFull = true;
				cout << "Error: only the first " << MAX_ARRAY
					<< " students will be read." << endl << endl;
			}
		} // end inner if

	} // end while

	inCreditData.close();

	return title;
}
//*************************************************************************
studentLevel studentNum(int numCredits)
{
	studentLevel title;

	if (numCredits < 32)
		title = FRESHMAN;
	else if (numCredits >= 32 && numCredits <= 63)
		title = SOPHOMORE;
	else if (numCredits >= 64 && numCredits <= 95)
		title = JUNIOR;
	else
		title = SENIOR;

	return title;
}
//***************************************************************************
string studentTitle(studentLevel level)
{
	string name;
	switch (level)
	{
	case 0:
		name = "Freshman";
		break;
	case 1:
		name = "Sophomore";
		break;
	case 2:
		name = "Junior";
		break;
	case 3:
		name = "Senior";
	}

	return name;
}
//***************************************************************************
void selectSort(string array[], int& cnt)
{
	int curTop,          // Current top of unsorted list
		next,            // Position to compare value to
		max;       	     // Position of greatest value
	string temp;         // Temp value for swapping

	// for each item in the list (top to bottom)
	for (curTop = 0; curTop < cnt - 1; curTop++)
	{
		max = curTop;      // start with current top as greatest value

		// find greatest value from curTop down
		for (next = curTop + 1; next < cnt; next++)
			if (array[next] > array[max])
			{
				max = next;
				array[max] = array[next];

			}

		//if greatest not at curTop, swap with curTop
		if (max != curTop)
		{
			temp = array[curTop];
			array[curTop] = array[max];
			array[max] = temp;
		}   // end swap
	}
	return;
}

#include <iostream>
#include <string>

// return the position of the largest element. invariant: n > 0
std::size_t pos_largest( const std::string array[], std::size_t n )
{
    std::size_t pos_largest = 0 ;
    for( std::size_t i = 1 ; i < n ; ++i )
        if( array[pos_largest] < array[i] ) pos_largest = i ;
    return pos_largest ;
}

void do_swap( std::string& a, std::string& b ) // simple swap, not using move
{
    std::string temp = a ;
    a = b ;
    b = temp ;
}

// for both arrays, bring the element at position 'pos' to the front
void bring_to_front( std::string a[], std::string b[], std::size_t pos )
{
    do_swap( a[0], a[pos] ) ;
    do_swap( b[0], b[pos] ) ;
}

// sort descending on key, keeping value aligned with associated key
void sort_pairs( std::string key[], std::string value[], std::size_t n )
{
    if( n > 1 )
    {
        // get the largest value to the front of both sequences
        bring_to_front( key, value, pos_largest( key, n ) ) ;

        // repeat for the tail of (the remaining elements in) the sequences
        sort_pairs( key+1, value+1, n-1 ) ;
    }
}

int main()
{
    const std::size_t n = 5 ;
    std::string a[n] = { "2",   "0",    "4",    "1",   "3" } ;
    std::string b[n] = { "two", "zero", "four", "one", "three" } ;

    sort_pairs( a, b, n ) ; // sort on a, keeping b aligned with a
    for( std::size_t i = 0 ; i < n ; ++i ) std::cout << a[i] << ' ' << b[i] << '\n' ;
    std::cout << "--------------\n" ;

    sort_pairs( b, a, n ) ; // sort on b, keeping a aligned with b
    for( std::size_t i = 0 ; i < n ; ++i ) std::cout << b[i] << ' ' << a[i] << '\n' ;
}