#include <iostream>
#include <iomanip>
#include <string>
#include <stdio.h>

#include "SelectionSort.cpp"
#include "BubbleSort.cpp"
#include "InsertionSort.cpp"
#include "MergeSort.cpp"
#include "QuickSort.cpp"
#include "ModifiedInsertionSort.cpp"
#include "RandomizedQuickSort.cpp"
#include "HeapSort.cpp"
#include "RandomArrayGen.cpp"

using namespace std;




struct resultStruct{
	long int incr;
	double time;
}result;
void mainMenu();
int setInput();
resultStruct runSelectionSort(int *);
resultStruct runBubbleSort(int *);
resultStruct runInsertionSort(int *);
resultStruct runModifiedInsertionSort(int *);
resultStruct runMergeSort(int *);
resultStruct runQuickSort(int *);
resultStruct runRandomizedQuickSort(int *);
resultStruct runHeapSort(int *);
void runFullTest();
//void output(ostream out);
void output();
void output(string sort);


int n = 0, N = 0, type = 0;

// results<n> [ type ] [ sort ]
double results100t[3][8];
double results1000t[3][8];
double results10000t[3][8];
double results30000t[3][8];
int results100i[3][8];
int results1000i[3][8];
int results10000i[3][8];
int results30000i[3][8];

int* testData100[3];
int* testData1000[3];
int* testData10000[3];
int* testData30000[3];

int individualResultsIncr;
double individualResultsTime;

void createData()
{
	
		RandomArrayGen test0= RandomArrayGen(100, 0);
		RandomArrayGen test1= RandomArrayGen(100, 1);
		RandomArrayGen test2= RandomArrayGen(100, 2);
		testData100[0] = test0.getArray();
		testData100[1] = test1.getArray();
		testData100[2] = test2.getArray();
	
		test0= RandomArrayGen(1000, 0);
		test1= RandomArrayGen(1000, 1);
		test2= RandomArrayGen(1000, 2);
		testData1000[0] = test0.getArray();
		testData1000[1] = test1.getArray();
		testData1000[2] = test2.getArray();
	
		test0= RandomArrayGen(10000, 0);
		test1= RandomArrayGen(10000, 1);
		test2= RandomArrayGen(10000, 2);
		testData10000[0] = test0.getArray();
		testData10000[1] = test1.getArray();
		testData10000[2] = test2.getArray();

		test0= RandomArrayGen(300000, 0);
		test1= RandomArrayGen(300000, 1);
		test2= RandomArrayGen(300000, 2);
		testData30000[0] = test0.getArray();
		testData30000[1] = test1.getArray();
		testData30000[2] = test2.getArray();
	





	

}

int main()
{
	createData();
	mainMenu();
	return 0;
}


void mainMenu()
{
	int userChoice = 0;

	do{
		cout << "Make a selection\n";
		cout << "1) Selection Sort\n";
		cout << "2) Bubble Sort\n";
		cout << "3) Insertion Sort\n";
		cout << "4) Modified Insertion Sort\n";
		cout << "5) Merge Sort\n";
		cout << "6) Quick Sort\n";
		cout << "7) Randomized Quick Sort\n";
		cout << "8) Heap Sort\n";
		cout << "9) Full Test (takes time)\n";
		cout << "0) Exit\n";

		cin >> userChoice;

		if(userChoice != 9 && userChoice != 0)
			setInput();
		int* array;
		switch(n)
		{
			case 0: 
				array = testData100[type];
				break;
			case 1:
				array = testData1000[type];
				break;
			case 2:
				array = testData10000[type];
				break;
			case 3:
			default:
				array = testData30000[type];
				break;
		}
		
			
		switch(userChoice)
		{
			case 0: 
				break;
			case 1:
				result = runSelectionSort(array);
				output("Selection Sort");
				break;
			case 2:
				result = runBubbleSort(array);
				output("Bubble Sort");
				break;
			case 3: 
				result = runInsertionSort(array);
				output("Insertion Sort");
				break;
			case 4: 
				result = runModifiedInsertionSort(array);
				output("Modified Insertion Sort");
				break;
			case 5:
				result = runMergeSort(array);
				output("Merge Sort");
				break;
			case 6: 
				result = runQuickSort(array);
				output("Quick Sort");
				break;
			case 7: 
				result = runRandomizedQuickSort(array);
				output("Randomized Quick Sort");
				break;
			case 8:
				result = runHeapSort(array);
				output("Heap Sort");
				break;
			case 9:
				runFullTest();
				break;
			default: break;
		}
	}while(userChoice != 0);
}


int setInput()
{
	int userChoiceInputMenu1 = 9;
	int userChoiceInputMenu2 = 9;

	cout << "*********************************\n";
	cout << "*         Setting Input         *\n";
	cout << "*********************************\n\n";

	cout << "Please input which size array you would like to use.\n\n";
	cout << "0) 100\n";
	cout << "1) 1000\n";
	cout << "2) 10000\n";
	cout << "3) 30000\n";
	cout << "9) Cancel\n\n\n";

	cin >> userChoiceInputMenu1;

	cout << "Please input which type array you would like to use.\n\n";
	cout << "0) Increasing\n";
	cout << "1) Decreasing\n";
	cout << "2) Randomized\n";
	cout << "9) Cancel\n";

	cin >> userChoiceInputMenu2;

	switch(userChoiceInputMenu1)
	{
		case 0:
			N = 100;
			break;
		case 1:
			N = 1000;
			break;
		case 2:
			N = 10000;
			break;
		case 3:
			N = 30000;
			break;
		case 9:
		default:
			return 1;
			break;
	}
	
	n = userChoiceInputMenu1;


	
	
	if(userChoiceInputMenu2 == 9)
		return 1;
	
	else
		type = userChoiceInputMenu2;
	return 1;
}

void output(string sort)
{
	cout << "\n\n";
	cout << "Results for " << " on array of ";
	switch(n)
	{
		case 0: cout << "100 ";
			break;
		case 1: cout << "1000 ";
			break;
		case 2: cout << "10000 ";
			break;
		case 3:
		default: cout << "30000 ";
			break;
	}
	cout << "elements of ";
	switch(type)
	{
		case 0: cout << "increasing ";
			break;
		case 1: cout << "decreasing ";
			break;
		case 2: 
		default: cout << "randomized ";
			break;
	}
	cout << " data.\n\n";

	cout << "Increments: " << result.incr << " comparisons\n";
	cout << "Time Taken: " << result.time << " seconds\n\n\n";
	result.incr = 0;
	result.time = 0;
}


resultStruct runSelectionSort(int* array)
{
	resultStruct r;
	SelectionSort* selection = new SelectionSort(array, N);
	selection->sort();
	r.time = selection->getTime();
	r.incr = selection->getIncrements();
	return r;
	delete selection;
}

resultStruct runBubbleSort(int* array)
{
	resultStruct r;
	BubbleSort* bubble = new BubbleSort(array, N);
	bubble->sort();
	r.time = bubble->getTime();
	r.incr = bubble->getIncrements();
	return r;
}

resultStruct runInsertionSort(int* array)
{
	resultStruct r;
	InsertionSort* insertion = new InsertionSort(array, N);
	insertion->sort();
	r.time = insertion->getTime();
	r.incr = insertion->getIncrements();
	return r;
}

resultStruct runModifiedInsertionSort(int* array)
{
	resultStruct r;
	ModifiedInsertionSort* mInsertion = new ModifiedInsertionSort(array, N);
	mInsertion->sort();
	r.time = mInsertion->getTime();
	r.incr = mInsertion->getIncrements();
	return r;
}

resultStruct runMergeSort(int* array)
{
	resultStruct r;
	MergeSort* merge = new MergeSort(array, N);
	merge->sort();
	r.time = merge->getTime();
	r.incr = merge->getIncrements();
	return r;
}

resultStruct runQuickSort(int* array)
{
	resultStruct r;
	QuickSort* quick = new QuickSort(array, N);
	quick->sort();
	r.time = quick->getTime();
	r.incr = quick->getIncrements();
	return r;
}

resultStruct runRandomizedQuickSort(int* array)
{
	resultStruct r;
	RandomizedQuickSort* rQuick = new RandomizedQuickSort(array, N);
	rQuick->sort();
	r.time = rQuick->getTime();
	r.incr = rQuick->getIncrements();
	return r;
}

resultStruct runHeapSort(int* array)
{
	resultStruct r;
	HeapSort* heap = new HeapSort(array, N);
	heap->sort();
	r.time = heap->getTime();
	r.incr = heap->getIncrements();
	return r;
}

void runFullTest()
{
	int* array;
	int type = 0;
	for(type = 0; type < 3; type++)
	{
		cout << "running on type " << type << endl;
		//-------------------------------------/
		// For 100 arrays
		//-------------------------------------/


		cout << "Setting array\n";
		array = testData100[type];
		cout << "Setting array done\n";
		cout.flush();
		N = 100;

		cout << "Running tests on 100\n";
		cout.flush();


		cout << "100 - Selection sort\n";
		cout.flush();
		result = runSelectionSort(array);
		results100i[type][0] = result.incr;
		results100t[type][0] = result.time;

		cout << "100 - Bubble sort\n";
		cout.flush();
		result = runBubbleSort(array);
		results100i[type][1] = result.incr;
		results100t[type][1] = result.time;

		cout << "100 - Insertion sort\n";
		cout.flush();
		result = runInsertionSort(array);
		results100i[type][2] = result.incr;
		results100t[type][2] = result.time;

		cout << "100 - M Insertion sort\n";
		result = runModifiedInsertionSort(array);
		results100i[type][3] = result.incr;
		results100t[type][3] = result.time;
		cout.flush();


		cout << "100 - Merge sort\n";
		cout.flush();
		result = runMergeSort(array);
		results100i[type][4] = result.incr;
		results100t[type][4] = result.time;

		cout << "100 - Quick sort\n";
		cout.flush();
		result = runQuickSort(array);
		results100i[type][5] = result.incr;
		results100t[type][5] = result.time;

		cout << "100 - Rand. Quick sort\n";
		result = runRandomizedQuickSort(array);
		results100i[type][6] = result.incr;
		results100t[type][6] = result.time;
		cout.flush();

		cout << "100 - Heap sort\n";
		cout.flush();
		result = runHeapSort(array);
		results100i[type][7] = result.incr;
		results100t[type][7] = result.time;

		/*-------------------------------------*/
		// For 1000 arrays
		/*-------------------------------------*/
		array = testData1000[type];
		N = 1000;

		cout << "Running tests on 1000\n";
		cout.flush();

		cout << "1000 -  1sort\n";
		cout.flush();
		result = runSelectionSort(array);
		results1000i[type][0] = result.incr;
		results1000t[type][0] = result.time;

		cout << "1000 -  2sort\n";
		cout.flush();
		result = runBubbleSort(array);
		results1000i[type][1] = result.incr;
		results1000t[type][1] = result.time;

		cout << "1000 -  3sort\n";
		cout.flush();
		result = runInsertionSort(array);
		results1000i[type][2] = result.incr;
		results1000t[type][2] = result.time;

		cout << "1000 -  4sort\n";
		cout.flush();
		result = runModifiedInsertionSort(array);
		results1000i[type][3] = result.incr;
		results1000t[type][3] = result.time;


		cout << "1000 -  5sort\n";
		cout.flush();
		result = runMergeSort(array);
		results1000i[type][4] = result.incr;
		results1000t[type][4] = result.time;

		cout << "1000 -  6sort\n";
		cout.flush();
		result = runQuickSort(array);
		results1000i[type][5] = result.incr;
		results1000t[type][5] = result.time;

		cout << "1000 -  7sort\n";
		cout.flush();
		result = runRandomizedQuickSort(array);
		results1000i[type][6] = result.incr;
		results1000t[type][6] = result.time;

		cout << "1000 -  8sort\n";
		cout.flush();
		result = runHeapSort(array);
		results1000i[type][7] = result.incr;
		results1000t[type][7] = result.time;

		/*-------------------------------------*/
		// For 10000 arrays
		/*-------------------------------------*/
		array = testData10000[type];
		N = 10000;

		cout << "Running tests on 10000\n";
		cout.flush();

		
		cout << "10000 -  1sort\n";
		cout.flush();
		result = runSelectionSort(array);
		results10000i[type][0] = result.incr;
		results10000t[type][0] = result.time;

		cout << "10000 -  2sort\n";
		cout.flush();
		result = runBubbleSort(array);
		results10000i[type][1] = result.incr;
		results10000t[type][1] = result.time;

		cout << "10000 -  3sort\n";
		cout.flush();
		result = runInsertionSort(array);
		results10000i[type][2] = result.incr;
		results10000t[type][2] = result.time;

		cout << "10000 -  4sort\n";
		cout.flush();
		result = runModifiedInsertionSort(array);
		results10000i[type][3] = result.incr;
		results10000t[type][3] = result.time;


		cout << "10000 -  5sort\n";
		cout.flush();
		result = runMergeSort(array);
		results10000i[type][4] = result.incr;
		results10000t[type][4] = result.time;

		cout << "10000 -  6sort\n";
		cout.flush();
		result = runQuickSort(array);
		results10000i[type][5] = result.incr;
		results10000t[type][5] = result.time;

		cout << "10000 -  7sort\n";
		cout.flush();
		result = runRandomizedQuickSort(array);
		results10000i[type][6] = result.incr;
		results10000t[type][6] = result.time;

		cout << "10000 -  8sort\n";
		cout.flush();
		result = runHeapSort(array);
		results10000i[type][7] = result.incr;
		results10000t[type][7] = result.time;

		/*-------------------------------------*/
		// For 30000 arrays
		/*-------------------------------------*/
		array = testData30000[type];
		N = 30000;
		cout << "Running tests on 30000\n";
		cout.flush();

		cout << "30000 -  1sort\n";
		cout.flush();
		result = runSelectionSort(array);
		results30000i[type][0] = result.incr;
		results30000t[type][0] = result.time;

		cout << "30000 -  2sort\n";
		cout.flush();
		result = runBubbleSort(array);
		results30000i[type][1] = result.incr;
		results30000t[type][1] = result.time;

		cout << "30000 -  3sort\n";
		cout.flush();
		result = runInsertionSort(array);
		results30000i[type][2] = result.incr;
		results30000t[type][2] = result.time;

		cout << "30000 -  4sort\n";
		cout.flush();
		result = runModifiedInsertionSort(array);
		results30000i[type][3] = result.incr;
		results30000t[type][3] = result.time;


		cout << "30000 -  5sort\n";
		cout.flush();
		result = runMergeSort(array);
		results30000i[type][4] = result.incr;
		results30000t[type][4] = result.time;

		cout << "30000 -  6sort\n";
		cout.flush();
		result = runQuickSort(array);
		results30000i[type][5] = result.incr;
		results30000t[type][5] = result.time;

		cout << "30000 -  7sort\n";
		cout.flush();
		result = runRandomizedQuickSort(array);
		results30000i[type][6] = result.incr;
		results30000t[type][6] = result.time;

		cout << "30000 -  8sort\n";
		cout.flush();
		result = runHeapSort(array);
		results30000i[type][7] = result.incr;
		results30000t[type][7] = result.time;
		cout << "Done testing type " << type << endl;
	}

	cout << "DONE TESTING" << endl;

	output();
}






//void output(ostream out)
void output()
{

	cout << "********************************************\n";
	cout << "**              Test Results              **\n";
	cout << "********************************************\n\n";
	
	cout << "For array of 100 elements  (Increments)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results100i[0][0] << "\t\t" << results100i[1][0] << "\t\t" << results100i[2][0] << endl;
	cout << "Bubble     \t" << results100i[0][1] << "\t\t" << results100i[1][1] << "\t\t" << results100i[2][1] << endl;
	cout << "Insetion   \t" << results100i[0][2] << "\t\t" << results100i[1][2] << "\t\t" << results100i[2][2] << endl;
	cout << "M.Insertion\t" << results100i[0][3] << "\t\t" << results100i[1][3] << "\t\t" << results100i[2][3] << endl;
	cout << "Merge      \t" << results100i[0][4] << "\t\t" << results100i[1][4] << "\t\t" << results100i[2][4] << endl;
	cout << "Quick      \t" << results100i[0][5] << "\t\t" << results100i[1][5] << "\t\t" << results100i[2][5] << endl;
	cout << "Rand. Quick\t" << results100i[0][6] << "\t\t" << results100i[1][6] << "\t\t" << results100i[2][6] << endl;
	cout << "Heap       \t" << results100i[0][7] << "\t\t" << results100i[1][7] << "\t\t" << results100i[2][7] << endl;
	
	cout << "For array of 1000 elements  (Increments)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results1000i[0][0] << "\t\t" << results1000i[1][0] << "\t\t" << results1000i[2][0] << endl;
	cout << "Bubble     \t" << results1000i[0][1] << "\t\t" << results1000i[1][1] << "\t\t" << results1000i[2][1] << endl;
	cout << "Insetion   \t" << results1000i[0][2] << "\t\t" << results1000i[1][2] << "\t\t" << results1000i[2][2] << endl;
	cout << "M.Insertion\t" << results1000i[0][3] << "\t\t" << results1000i[1][3] << "\t\t" << results1000i[2][3] << endl;
	cout << "Merge      \t" << results1000i[0][4] << "\t\t" << results1000i[1][4] << "\t\t" << results1000i[2][4] << endl;
	cout << "Quick      \t" << results1000i[0][5] << "\t\t" << results1000i[1][5] << "\t\t" << results1000i[2][5] << endl;
	cout << "Rand. Quick\t" << results1000i[0][6] << "\t\t" << results1000i[1][6] << "\t\t" << results1000i[2][6] << endl;
	cout << "Heap       \t" << results1000i[0][7] << "\t\t" << results1000i[1][7] << "\t\t" << results1000i[2][7] << endl;

	cout << "For array of 10000 elements  (Increments)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results10000i[0][0] << "\t" << results10000i[1][0] << "\t" << results10000i[2][0] << endl;
	cout << "Bubble     \t" << results10000i[0][1] << "\t" << results10000i[1][1] << "\t" << results10000i[2][1] << endl;
	cout << "Insetion   \t" << results10000i[0][2] << "\t\t" << results10000i[1][2] << "\t" << results10000i[2][2] << endl;
	cout << "M.Insertion\t" << results10000i[0][3] << "\t\t" << results10000i[1][3] << "\t" << results10000i[2][3] << endl;
	cout << "Merge      \t" << results10000i[0][4] << "\t\t" << results10000i[1][4] << "\t\t" << results10000i[2][4] << endl;
	cout << "Quick      \t" << results10000i[0][5] << "\t\t" << results10000i[1][5] << "\t\t" << results10000i[2][5] << endl;
	cout << "Rand. Quick\t" << results10000i[0][6] << "\t\t" << results10000i[1][6] << "\t\t" << results10000i[2][6] << endl;
	cout << "Heap       \t" << results10000i[0][7] << "\t\t" << results10000i[1][7] << "\t\t" << results10000i[2][7] << endl;


	cout << "For array of 30000 elements  (Increments)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results30000i[0][0] << "\t" << results30000i[1][0] << "\t" << results30000i[2][0] << endl;
	cout << "Bubble     \t" << results30000i[0][1] << "\t" << results30000i[1][1] << "\t" << results30000i[2][1] << endl;
	cout << "Insetion   \t" << results30000i[0][2] << "\t\t" << results30000i[1][2] << "\t" << results30000i[2][2] << endl;
	cout << "M.Insertion\t" << results30000i[0][3] << "\t\t" << results30000i[1][3] << "\t" << results30000i[2][3] << endl;
	cout << "Merge      \t" << results30000i[0][4] << "\t\t" << results30000i[1][4] << "\t\t" << results30000i[2][4] << endl;
	cout << "Quick      \t" << results30000i[0][5] << "\t\t" << results30000i[1][5] << "\t\t" << results30000i[2][5] << endl;
	cout << "Rand. Quick\t" << results30000i[0][6] << "\t\t" << results30000i[1][6] << "\t\t" << results30000i[2][6] << endl;
	cout << "Heap       \t" << results30000i[0][7] << "\t\t" << results30000i[1][7] << "\t\t" << results30000i[2][7] << endl;

/*--------------------------------*/
/*  FOR TIMES					  */
/*--------------------------------*/
	cout << "For array of 100 elements  (Times)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results100t[0][0] << "\t\t" << results100t[1][0] << "\t\t" << results100t[2][0] << endl;
	cout << "Bubble     \t" << results100t[0][1] << "\t\t" << results100t[1][1] << "\t\t" << results100t[2][1] << endl;
	cout << "Insetion   \t" << results100t[0][2] << "\t\t" << results100t[1][2] << "\t\t" << results100t[2][2] << endl;
	cout << "M.Insertion\t" << results100t[0][3] << "\t\t" << results100t[1][3] << "\t\t" << results100t[2][3] << endl;
	cout << "Merge      \t" << results100t[0][4] << "\t\t" << results100t[1][4] << "\t\t" << results100t[2][4] << endl;
	cout << "Quick      \t" << results100t[0][5] << "\t\t" << results100t[1][5] << "\t\t" << results100t[2][5] << endl;
	cout << "Rand. Quick\t" << results100t[0][6] << "\t\t" << results100t[1][6] << "\t\t" << results100t[2][6] << endl;
	cout << "Heap       \t" << results100t[0][7] << "\t\t" << results100t[1][7] << "\t\t" << results100t[2][7] << endl;
	
	cout << "For array of 1000 elements  (Times)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results1000t[0][0] << "\t\t" << results1000t[1][0] << "\t\t" << results1000t[2][0] << endl;
	cout << "Bubble     \t" << results1000t[0][1] << "\t\t" << results1000t[1][1] << "\t\t" << results1000t[2][1] << endl;
	cout << "Insetion   \t" << results1000t[0][2] << "\t\t" << results1000t[1][2] << "\t\t" << results1000t[2][2] << endl;
	cout << "M.Insertion\t" << results1000t[0][3] << "\t\t" << results1000t[1][3] << "\t\t" << results1000t[2][3] << endl;
	cout << "Merge      \t" << results1000t[0][4] << "\t\t" << results1000t[1][4] << "\t\t" << results1000t[2][4] << endl;
	cout << "Quick      \t" << results1000t[0][5] << "\t\t" << results1000t[1][5] << "\t\t" << results1000t[2][5] << endl;
	cout << "Rand. Quick\t" << results1000t[0][6] << "\t\t" << results1000t[1][6] << "\t\t" << results1000t[2][6] << endl;
	cout << "Heap       \t" << results1000t[0][7] << "\t\t" << results1000t[1][7] << "\t\t" << results1000t[2][7] << endl;

	cout << "For array of 10000 elements  (Times)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results10000t[0][0] << "\t\t" << results10000t[1][0] << "\t\t" << results10000t[2][0] << endl;
	cout << "Bubble     \t" << results10000t[0][1] << "\t\t" << results10000t[1][1] << "\t\t" << results10000t[2][1] << endl;
	cout << "Insetion   \t" << results10000t[0][2] << "\t\t" << results10000t[1][2] << "\t\t" << results10000t[2][2] << endl;
	cout << "M.Insertion\t" << results10000t[0][3] << "\t\t" << results10000t[1][3] << "\t\t" << results10000t[2][3] << endl;
	cout << "Merge      \t" << results10000t[0][4] << "\t\t" << results10000t[1][4] << "\t\t" << results10000t[2][4] << endl;
	cout << "Quick      \t" << results10000t[0][5] << "\t\t" << results10000t[1][5] << "\t\t" << results10000t[2][5] << endl;
	cout << "Rand. Quick\t" << results10000t[0][6] << "\t\t" << results10000t[1][6] << "\t\t" << results10000t[2][6] << endl;
	cout << "Heap       \t" << results10000t[0][7] << "\t\t" << results10000t[1][7] << "\t\t" << results10000t[2][7] << endl;


	cout << "For array of 30000 elements  (Times)\n";
	cout << "Type of Sort\tIncreasing\tDecreasing\tRandomized\n";
	cout << "----------------------------------------------------------\n";
	cout << "Selection  \t" << results30000t[0][0] << "\t\t" << results30000t[1][0] << "\t\t" << results30000t[2][0] << endl;
	cout << "Bubble     \t" << results30000t[0][1] << "\t\t" << results30000t[1][1] << "\t\t" << results30000t[2][1] << endl;
	cout << "Insetton   \t" << results30000t[0][2] << "\t\t" << results30000t[1][2] << "\t\t" << results30000t[2][2] << endl;
	cout << "M.Insertion\t" << results30000t[0][3] << "\t\t" << results30000t[1][3] << "\t\t" << results30000t[2][3] << endl;
	cout << "Merge      \t" << results30000t[0][4] << "\t\t" << results30000t[1][4] << "\t\t" << results30000t[2][4] << endl;
	cout << "Quick      \t" << results30000t[0][5] << "\t\t" << results30000t[1][5] << "\t\t" << results30000t[2][5] << endl;
	cout << "Rand. Quick\t" << results30000t[0][6] << "\t\t" << results30000t[1][6] << "\t\t" << results30000t[2][6] << endl;
	cout << "Heap       \t" << results30000t[0][7] << "\t\t" << results30000t[1][7] << "\t\t" << results30000t[2][7] << endl;
}