fin >> judgeNumber[i][j];
			if (!fin || judgeNumber[i][j] == -1)
			{
				judgeCount[i] = j;
				break;
			}
 
			fin >> score[i][j];
			if (!fin)
			{
				judgeCount[i] = j;
				break;
			}

#include <algorithm>

void SortAverage ()
{
	int mvt[MAXMEMBERS];
	for (int i = 0; i < numPlayers - 1; ++i)
	{
		double max = average[i];
		for (int j = i + 1;  j < numPlayers; ++j)
		{
			if (max < average[j])
			{
				max = average[j];
				mvt[i] = j;
			}
		}
		if (i != mvt[i])
			swap(average[i], average[mvt[i]]);
	}
	for (int i = 0; i < (numPlayers - 1); ++i)
	{
		if (mvt[i] != 0)
		{
			swap(pianoPlayer[i], pianoPlayer[mvt[i]]);
			swap(weightFactor[i], weightFactor[mvt[i]]);
			swap(profLevel[i], profLevel[mvt[i]]);
			swap(judgeCount[i], judgeCount[mvt[i]]);
			for (int j = 0; j < MAXJUDGES; ++j)
			{
				swap(score[i][j], score[mvt[i]][j]);
				swap(judgeNumber[i][j], judgeNumber[mvt[i]][j]);
				swap(weightedScore[i][j], weightedScore[mvt[i]][j]);
			}
		}
	}
}

void SwitchProfLevel(ofstream& fout, const int& i)

void SortAverage ()
{
	int mvt[MAXMEMBERS];
	for (int i = 0; i < numPlayers - 1; ++i)
	{
		double max = average[i];
		for (int j = i + 1;  j < numPlayers; ++j)
		{
			if (max < average[j])
			{
				max = average[j];
				mvt[i] = j;
			}
		}
		if (mvt[i] != 0)
			swap(average[i], average[mvt[i]]);
	}
	for (int i = 0; i < (numPlayers - 1); ++i)
	{
		if (mvt[i] != 0)
		{
			swap(pianoPlayer[i], pianoPlayer[mvt[i]]);
			swap(weightFactor[i], weightFactor[mvt[i]]);
			swap(profLevel[i], profLevel[mvt[i]]);
			swap(judgeCount[i], judgeCount[mvt[i]]);
			for (int j = 0; j < MAXJUDGES; ++j)
			{
				swap(score[i][j], score[mvt[i]][j]);
				swap(judgeNumber[i][j], judgeNumber[mvt[i]][j]);
				swap(weightedScore[i][j], weightedScore[mvt[i]][j]);
			}
		}
	}
}

void selectionSort(arrayType * arrayName, int array_size)
  int i, j;   //loop counters
  int index;  //index of the minimal (or maximum if you are doing descending sort) value 
 
  declare outer loop to control what element you start at within arrayName.  i should range from zero to arraySize minus two.
  In the outer loop body:
       assume that current element is the extreme (smallest or largest, whatever) so assign i to index
       use an inner loop to look at all element in array with indexes higher than i (j should range from i + 1 to arraySize minus 1)
            in inner loop body:
                if(arrayName[index] less than (or greater than depending on whether sorting in ascending or descending order) arrayName[j])
                   assign j to index
      when inner loop is done the element at arrayName[index] will be the extreme value (low or high) of the unsorted elements
           if(index is not the same as i)
               then need to swap elements with indexes of index and i in all appropriate parallel arrays
 
Pseudocode to swap elements of an array:
void swapElements(int i, int j, arrayType1 * array1Name)
  arrayType1  temp
 
  temp = array1Name[i]
  array1Name[i] = array1Name[j]
  array1Name[j] = temp

void SelectionSort()
{
	int numPlayers;
	int i, j;
	int lowIndex, temp;
	int mvt[MAXMEMBERS];
	for (int i = 0; i < (numPlayers - 1); i++)
	{
		lowIndex=i;
		for (numPlayers=0; numPlayers < i-1; numPlayers++)
		{
			if (mv
		if (mvt[i] != 0)
		{
			swap(pianoPlayer[i], pianoPlayer[mvt[i]]);
			swap(weightFactor[i], weightFactor[mvt[i]]);
			swap(profLevel[i], profLevel[mvt[i]]);
			swap(judgeCount[i], judgeCount[mvt[i]]);
			for (int j = 0; j < MAXJUDGES; ++j)
			{
				swap(score[i][j], score[mvt[i]][j]);
				swap(judgeNumber[i][j], judgeNumber[mvt[i]][j]);
				swap(weightedScore[i][j], weightedScore[mvt[i]][j]);
			}
		}
	}
}

void SelectionSort(double WeightedScore[MAXMEMBERS], int numPlayers)
{
	int i, j;
	double indexOfNextSmallest;
	for (int i = 0; i < (numPlayers-1); i++)
	{
		for (j = i+1; j < numPlayers+1; j++)
		{
			indexOfNextSmallest = indexOfSmallest(weightedScore, startIndex, numPlayers);
			SwapValues(weightedScore[i], weightedScore[indexOfNextSmallest]);
		}
	}		
}
void SwapValues(int& v1, int& v2)
{
	int temp;
	temp = v1;
	v1 = v2;
	v2 = temp;
}
double indexOfSmallest(double weightedScore[MAXMEMBERS], int startIndex, int numPlayers)
{
	int min = weightedScore[startIndex],
		indexOfMin = startIndex;
	for (i = startIndex +1; i < numPlayers; i++)
	{	
		if (weightedScore[i] < min)
		{
			min = weightedScore[i];
			indexOfMin = index;
		}
	}
	return indexOfMin;
}