Advanced Sorting Techniques

	Merge Sort
	
		A merge sort assumes you have two already sorted arrays that you want to
		merge together.  The two arrays are merged into a third that is equal in
		size to the sum of the first two,
		
		If you have two arrays to merge, A and B, and the third to merge into C:
		
			1. Set the current position of all arrays to the first element.
			2. Compare the current elements of two arrays to merge and move the
				smaller value into the current position at C.
			3. Advance the current position of C and the array with the
				smaller value.
			
			Iterative Process:
			
				Repeat steps 2 and 3 until one array is exhausted.
				
			Once an array is exhausted, simply copy the remaining elements of
			the other array into the new one.
	
		void Merge(string A[], int F, int Mid, int L) {
			int First1 = F;
			int Last1 = Mid;
			int First2 = Mid + 1;
			int Last2 = L;

			int index = First1;

			for (; (First1<=Last1) && (First2<=Last2); index++) {
				if ( strcmp(A[First1], A[First2]) < 0) {
					strcpy(tmpArray[index], A[First1]);
					First1++;
				}
				else {
					strcpy(tmpArray[index], A[First2]);
					First2++;
				}
			}

			for (; First1<=Last1; First1++, index++) {
				strcpy(tmpArray[index], A[First1]);
			}

			for (; First2<=Last2; First2++, index++) {
				strcpy(tmpArray[index], A[First2]);
			}

			for ( index=F; index<=L; index++ ) {
				strcpy(A[index], tmpArray[index]);
			}
			intMerge++;
		}


		How can we apply this to one unsorted array?
		
			We recursively the array in two by finding the mid-point.
			When the size is one, we have a sorted array to merge. 

			void MergeSort(string A[], int F, int L) {
				intSort++;
				if ( F < L ) {
					int Mid = (F + L) / 2;
					MergeSort(A, F, Mid);
					MergeSort(A, Mid+1, L);
					Merge(A, F, Mid, L);
				}
			}

	Quick Sort
	
		This sort partitions an array as follows:
		
			1. Picking a pivot value (one of the end values)
			2. Move all smaller values to the left of the pivot
			3. Move all larger values to the right of the pivot
			
			Recursive Process:
			
				Repeat steps with lower partition
				Repeat steps with upper partition

		void Partition(string A[], int F, int L, int& iPivot) {
			ChoosePivot(A, F, L);
			string sPivot = "";
			strcpy(sPivot, A[F]);
			int LastS1 = F;
			int FirstUnknown = F + 1;
			for (; FirstUnknown<=L; FirstUnknown++) {
				if ( strcmp(A[FirstUnknown], sPivot) < 0 ) {
					LastS1++;
					Swap(A[FirstUnknown], A[LastS1]);
				}
			}
			Swap(A[F], A[LastS1]);
			iPivot = LastS1;
			partCount++;
		}

		void QuickSort(string A[], int F, int L) {
			int Pivot;

			if ( F<L ) {
				Partition(A, F, L, Pivot);
				QuickSort(A, F, Pivot-1);
				QuickSort(A, Pivot+1, L);
			}

			sortCount++;
		}

	Picking a Better Pivot: Median of Three Partitioning
	
		If an array is truly random, then the odds are almost even that
		picking one of the end values will produce one that results in
		approximately even sized partitions. QuickSort is most efficient
		when this is true.
		
		You can increase your chances by applying the "Median of Three."
		The idea is this:  compare the values in both ends and the middle
		of the array.  Whichever of the three lands between the other two
		will be used as the partioning value.
	
		void ChoosePivot(string A[], int F, int L) {
			int M = (F + L) / 2;
			if ( strcmp(A[F], A[M]) > 0 )
				Swap(A[F], A[M]);
			if ( strcmp(A[M], A[L]) > 0 )
				Swap(A[M], A[L]);
		}

	
	Radix Sort

		A radix sort operates by grouping the data.
		
			1. Separate each string into a bin based on it's last character
			2. Pass through each string in all bins in order, comparing the
				next character in from the end.  Place the string in a
				bin based on that character.
			3. Repeat until you compared every position in the string
			4. Pull the strings from the bins in order.
			
		For simplicity sake, our example will require all strings to be the same length
		and limit the strings to digits.
		
		// Declare variables
		string binA[10][10];
		string binB[10][10];
		int posA[10];
		int posB[10];
		int binPos = 0;
		
		// Read the file into first column of binA
		ifstream inFile
		string input = "";
		while ( inFile ) {
			inFile.getLine(binA[count][posA[count]++]);
			count++;
		}

		// Repeatedly re-group the elements
		for ( int i=3; i>=0; i-- ) {
	
			// Group from binA to binB
			for ( int x=0; x<10; x++ ) {
				for ( int y=0; y<posA[x]; y++ ) {
					binPos = atoi((binA[x][y]).substring(i,i+1));
					strcpy(binB[binPos][posB[binPos]++], binA[x][y]);
				}
			}
			
			// Copy binB back to binA
			for ( int x=0; x<10; x++ ) {
				for ( int y=0; y<posB[x]; y++ ) {
					if ( (binB[x][y]) != null  && (binB[x][y]).length() != 0 ) {
						strcpy(binA[x][y], binB[x][y]);
						strcpy(binB[x][y], "");
					}
				}
				posA[x] = posB[x];
				posB[x] = 0;
			}
		}

		// Extract the ordered list from binB back to first column of binA
		count = 0;
		for ( int x=0; x<10; x++ ) {
			for ( int y=0; y<posA[x]; y++ ) {
				if ( (binA[x][y]) != null  && (binA[x][y]).length() != 0 ) {
					strcpy(binB[count++][0], binA[x][y]);
				}
			}
		}