#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <conio.h>


//if you use Windows then include windows.h and define OS_WIN constant
#if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
#define OS_WIN
#include <windows.h>
#endif

#define RMAX 1000
/*#define CLK_TCK 1000*/

//vars for countig swaps
unsigned long int	bubble_swap_count=0,	ins_swap_count=0,	sel_swap_count=0,	merge_swap_count=0;
//vars for countig comparations
unsigned long int	bubble_comp_count=0,	ins_comp_count=0,	sel_comp_count=0,	merge_comp_count=0;
//vars for calculating running time of algorithm
double				bubble_time,			ins_time,			sel_time,			merge_time;
//vars for reverse direction sorting (DESC), set it to '1' for reverse
short int			bubble_rev_dir=0,		ins_rev_dir=0,		sel_rev_dir=0,		merge_rev_dir=0;
//var for gotoxy() funcion
short int goto_line=5;

//these two functions are diferent for windows and unix (linux)!!!
#ifdef OS_WIN

	/* For Windows */
	void clear_screen()
	{
		system("cls");
	}

	void gotoxy(int x, int y)
	{
		COORD coord;
		coord.X = x;
		coord.Y = y;
		SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
	}
#else
	/* For Unix */
	void clear_screen()
	{
		system("CLEAR");
	}

	void gotoxy(int x, int y)
	{
		char essq[100];		// String variable to hold the escape sequence
		char xstr[100];		// Strings to hold the x and y coordinates
		char ystr[100];		// Escape sequences must be built with characters


		// Convert the screen coordinates to strings

		sprintf(xstr, "%d", x);
		sprintf(ystr, "%d", y);

		// Build the escape sequence (vertical move)

		essq[0] = '\0';
		strcat(essq, "\033[");
		strcat(essq, ystr);


		// Described in man terminfo as vpa=\E[%p1%dd
		// Vertical position absolute

		strcat(essq, "d");

		// Horizontal move
		// Horizontal position absolute

		strcat(essq, "\033[");
		strcat(essq, xstr);
		// Described in man terminfo as hpa=\E[%p1%dG
		strcat(essq, "G");

		// Execute the escape sequence
		// This will move the cursor to x, y

		printf("%s", essq);
	}
#endif

void pause (int ms)
{
  clock_t endwait;
  endwait = clock () + ms ;
  while (clock() < endwait) {}
}

clock_t BeginTimer()
{
    clock_t Begin; //initialize Begin
    Begin = clock(); //start the timer
    return Begin;
}

clock_t EndTimer(double begin)
{
	clock_t End;
    End = clock();   //stop the timer
    return End-begin;
}


/* fuelle array mit zufaelligen Werten (< RMAX) */
static void fill_array_int(int arr[], int n) {
	int i;
	for (i = 0; i < n; i++)
		arr[i] = rand() % RMAX;
}

static void fill_array_float(float arr[], int n) {
	int i;
	for (i = 0; i < n; i++)
		arr[i] = (rand()/(float)((RAND_MAX)+1)) * RMAX;
}

static void fill_array_double(double arr[], int n) {
	int i;
	for (i = 0; i < n; i++)
		arr[i] = (rand()/((double)(RAND_MAX+1))) * RMAX;
}

/* tausche den Inhalt zweier Variablen */
static void swap_int(int *a, int *b) {
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

static void swap_float(float *a, float *b) {
	float tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

static void swap_double(double *a, double *b) {
	double tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}


/********************* BUBBLE SORT ***********************/

/*-------------------BUBBLE INTEGER--------------------*/
static void bubble_sort_int(int arr[], int length)
{
	double begin = BeginTimer();
	int i, swapped;
	bubble_time = 0;
	bubble_swap_count = 0;
	do
	{
		swapped = 0;
		if (bubble_rev_dir)
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] < arr[i])
				{
					swap_int(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
		else
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] > arr[i])
				{
					swap_int(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
	} while (swapped);
	bubble_time = EndTimer(begin);
}

/*-------------------BUBBLE FLOAT--------------------*/
static void bubble_sort_float(float arr[], int length)
{
	double begin = BeginTimer();
	int i, swapped;
	bubble_time = 0;
	bubble_swap_count = 0;
	do
	{
		swapped = 0;
		if (bubble_rev_dir)
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] < arr[i])
				{
					swap_float(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
		else
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] > arr[i])
				{
					swap_float(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
	} while (swapped);
	bubble_time = EndTimer(begin);
}

/*-------------------BUBBLE DOUBLE--------------------*/
static void bubble_sort_double(double arr[], int length)
{
	double begin = BeginTimer();
	int i, swapped;
	bubble_time = 0;
	bubble_swap_count = 0;
	do
	{
		swapped = 0;
		if (bubble_rev_dir)
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] < arr[i])
				{
					swap_double(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
		else
		{
			for (i = 1; i < length; i++)
			{
				bubble_comp_count++;
				if (arr[i - 1] > arr[i])
				{
					swap_double(&arr[i - 1], &arr[i]);
					bubble_swap_count++;
					swapped = 1;
				}
			}
		}
	} while (swapped);
	bubble_time = EndTimer(begin);
}

/*\\\\\\\\\\\\\\\\\\ END BUBBLE SORT ///////////////////*/


/********************* INSERTION SORT ***********************/
/*--------------------INSERTION INTEGER---------------------*/
static void insertion_sort_int(int arr[], int length) {
	double begin = BeginTimer();
	int i, j, key;
	ins_time = 0;
	ins_swap_count = 0;
	if (ins_rev_dir)
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0 && key > arr[j]) {
					ins_swap_count++;
					arr[j + 1] = arr[j];
					j--;
				}
				arr[j + 1] = key;
			}
		}
	else
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0 && key < arr[j]) {
					arr[j + 1] = arr[j];
					ins_swap_count++;
					j--;
				}
				arr[j + 1] = key;
			}
		}
	ins_time = EndTimer(begin);
}

/*------------------INSERTION FLOAT--------------------*/
static void insertion_sort_float(float arr[], int length) {
	double begin = BeginTimer();
	int i, j;
	float key;
	ins_time = 0;
	ins_swap_count = 0;
	if (ins_rev_dir)
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0 && key > arr[j]) {
					ins_swap_count++;
					arr[j + 1] = arr[j];
					j--;
				}
				arr[j + 1] = key;
			}
		}
	else
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0 && key < arr[j]) {
					ins_swap_count++;
					arr[j + 1] = arr[j];
					j--;
				}
				arr[j + 1] = key;
			}
		}
	ins_time = EndTimer(begin);
}

/*------------------INSERTION DOUBLE--------------------*/
static void insertion_sort_double(double arr[], int length) {
	double begin = BeginTimer();
	int i, j;
	double key;
	ins_time = 0;
	ins_swap_count = 0;
	ins_comp_count = 0;
	if (ins_rev_dir)
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0)
					while (key > arr[j]) {
					ins_swap_count++;
					arr[j + 1] = arr[j];
					j--;
				}
				arr[j + 1] = key;
			}
		}
	else
		{
			for (i = 1; i < length; i++) {
				key = arr[i];
				j = i - 1;
				ins_comp_count++;
				while (j >= 0 && key < arr[j]) {
					ins_swap_count++;
					arr[j + 1] = arr[j];
					j--;
				}
				arr[j + 1] = key;
			}
		}
	ins_time = EndTimer(begin);
}

/*\\\\\\\\\\\\\\\\\\ END INSERTION SORT ///////////////////*/


/********************* SELECTION SORT ***********************/

/*-------------------SELECTION INTEGER--------------------*/
static void selection_sort_int(int arr[], int length) {
	double begin = BeginTimer();
	int i, j, min, max;
	sel_time = 0;
	sel_swap_count = 0;
	if (sel_rev_dir)
	{
		for (i = 0; i < length - 1; i++) {
			max = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] > arr[max])
					max = j;
				}
			swap_int(&arr[i], &arr[max]);
			sel_swap_count++;
		}
	}
	else
	{
		for (i = 0; i < length - 1; i++) {
			min = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] < arr[min])
					min = j;
				}
			swap_int(&arr[i], &arr[min]);
			sel_swap_count++;
		}
	}
	sel_time = EndTimer(begin);
}

/*------------------SELECTION FLOAT--------------------*/
static void selection_sort_float(float arr[], int length) {
	double begin = BeginTimer();
	int i, j, min, max;
	sel_time = 0;
	sel_swap_count = 0;
	if (sel_rev_dir)
	{
		for (i = 0; i < length - 1; i++) {
			max = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] > arr[max])
					max = j;
				}
			swap_float(&arr[i], &arr[max]);
			sel_swap_count++;
		}
	}
	else
	{
		for (i = 0; i < length - 1; i++) {
			min = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] < arr[min])
					min = j;
				}
			swap_float(&arr[i], &arr[min]);
			sel_swap_count++;
		}
	}
	sel_time = EndTimer(begin);
}
/*------------------SELECTION DOUBLE--------------------*/
static void selection_sort_double(double arr[], int length) {
	double begin = BeginTimer();
	int i, j, min, max;
	sel_time = 0;
	sel_swap_count = 0;
	if (sel_rev_dir)
	{
		for (i = 0; i < length - 1; i++) {
			max = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] > arr[max])
					max = j;
				}
			swap_double(&arr[i], &arr[max]);
			sel_swap_count++;
		}
	}
	else
	{
		for (i = 0; i < length - 1; i++) {
			min = i;
			for (j = i + 1; j < length; j++)
				{
				sel_comp_count++;
				if (arr[j] < arr[min])
					min = j;
				}
			swap_double(&arr[i], &arr[min]);
			sel_swap_count++;
		}
	}
	sel_time = EndTimer(begin);
}


/*\\\\\\\\\\\\\\\\ END SELECTION SORT /////////////////*/


/********************* MERGE SORT ***********************/

/*--------------------MERGE INTEGER---------------------*/

/* Fuege (merge) zwei sortierte Partitionen zusammen */
static void merge_int(int arr[], int l, int m, int r) {

	int *tmp = (int *) malloc(sizeof(int) * (m - l + 1));
	int i, j = 0, k = m + 1;
	merge_swap_count = 0;
	/* kopiere arr[l..m] in ein temporaeres Array */
	for (i = l; i <= m; i++)
		tmp[j++] = arr[i];
	/* vergleiche die Eintraege des temp. Arrays mit den Eintraegen arr[m+1..r] */
	i = l;
	j = 0;
	while (i < k && k <= r)
		{
		merge_comp_count++;
		if (tmp[j] <= arr[k])
			{
				arr[i++] = tmp[j++];
				merge_swap_count++;
			}
		else
			{
				arr[i++] = arr[k++];
				merge_swap_count++;
			}
		}
	/* kopiere eventuelle vorhandene Eintraege des temp. Arrays nach arr */
	while (i < k)
		{
			arr[i++] = tmp[j++];
			merge_swap_count++;
		}
	free(tmp);
}

/* merge-sort */
static void merge_sorter_int(int arr[], int l, int r) {
	int m = (l + r) / 2;
	/* arr[l..r] hat min. zwei Elemente <=> l < r */
	if (l < r) {
		/* sortiere ersten Teil */
		merge_sorter_int(arr, l, m);
		/* sortiere zweiten Teil */
		merge_sorter_int(arr, m + 1, r);
		/* Fuege sortierte Teile zusammen */
		merge_int(arr, l, m, r);
	}
}
/* Wrapper für mergesorter */
static void merge_sort_int(int arr[], int n) {
	merge_time = 0;
	double begin = BeginTimer();
	merge_sorter_int(arr, 0, n - 1);
	merge_time = EndTimer(begin);
}

/*--------------------MERGE FLOAT---------------------*/

/* Fuege (merge) zwei sortierte Partitionen zusammen */
static void merge_float(float arr[], int l, int m, int r) {

	float *tmp = (float *) malloc(sizeof(float) * (m - l + 1));

	int i, j = 0, k = m + 1;
	merge_swap_count = 0;
	/* kopiere arr[l..m] in ein temporaeres Array */
	for (i = l; i <= m; i++)
		tmp[j++] = arr[i];
	/* vergleiche die Eintraege des temp. Arrays mit den Eintraegen arr[m+1..r] */
	i = l;
	j = 0;
	while (i < k && k <= r)
		{
		merge_comp_count++;
		if (tmp[j] <= arr[k])
			{
				arr[i++] = tmp[j++];
				merge_swap_count++;
			}
		else
			{
				arr[i++] = arr[k++];
				merge_swap_count++;
			}
		}
	/* kopiere eventuelle vorhandene Eintraege des temp. Arrays nach arr */
	while (i < k)
		{
			arr[i++] = tmp[j++];
			merge_swap_count++;
		}
	free(tmp);
}
/* merge-sort */
static void merge_sorter_float(float arr[], int l, int r) {
	int m = (l + r) / 2;
	/* arr[l..r] hat min. zwei Elemente <=> l < r */
	if (l < r) {
		/* sortiere ersten Teil */
		merge_sorter_float(arr, l, m);
		/* sortiere zweiten Teil */
		merge_sorter_float(arr, m + 1, r);
		/* Fuege sortierte Teile zusammen */
		merge_float(arr, l, m, r);
	}
}
/* Wrapper für mergesorter */
static void merge_sort_float(float arr[], int n) {
	merge_time = 0;
	double begin = BeginTimer();
	merge_sorter_float(arr, 0, n - 1);
	merge_time = EndTimer(begin);
}

/*--------------------MERGE DOUBLE---------------------*/

/* Fuege (merge) zwei sortierte Partitionen zusammen */
static void merge_double(double arr[], int l, int m, int r) {
	double *tmp = (double *) malloc(sizeof(double) * (m - l + 1));
	int i, j = 0, k = m + 1;
	merge_swap_count = 0;
	/* kopiere arr[l..m] in ein temporaeres Array */
	for (i = l; i <= m; i++)
		tmp[j++] = arr[i];
	/* vergleiche die Eintraege des temp. Arrays mit den Eintraegen arr[m+1..r] */
	i = l;
	j = 0;
	while (i < k && k <= r)
		{
		merge_comp_count++;
		if (tmp[j] <= arr[k])
			{
				arr[i++] = tmp[j++];
				merge_swap_count++;
			}
		else
			{
				arr[i++] = arr[k++];
				merge_swap_count++;
			}
		}
	/* kopiere eventuelle vorhandene Eintraege des temp. Arrays nach arr */
	while (i < k)
		{
			arr[i++] = tmp[j++];
			merge_swap_count++;
		}
	free(tmp);
}

/* merge-sort */
static void merge_sorter_double(double arr[], int l, int r) {
	int m = (l + r) / 2;
	/* arr[l..r] hat min. zwei Elemente <=> l < r */
	if (l < r) {
		/* sortiere ersten Teil */
		merge_sorter_double(arr, l, m);
		/* sortiere zweiten Teil */
		merge_sorter_double(arr, m + 1, r);
		/* Fuege sortierte Teile zusammen */
		merge_double(arr, l, m, r);
	}
}
/* Wrapper für mergesorter */
static void merge_sort_double(double arr[], int n) {
	merge_time = 0;
	double begin = BeginTimer();
	merge_sorter_double(arr, 0, n - 1);
	merge_time = EndTimer(begin);
}


/*\\\\\\\\\\\\\\\\\\ END MERGE SORT ///////////////////*/

/* ueberpruefe, ob ein Array sortiert ist (zum Debuggen) */
static void check_sort_int(int arr[], int n, int DESC) {
	int i;
	for (i = 1; i < n; i++)

	if (DESC)
		{
			if (arr[i - 1] < arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
	else
		{
			if (arr[i - 1] > arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
}

static void check_sort_float(float arr[], int n, int DESC) {
	int i;
	for (i = 1; i < n; i++)

	if (DESC)
		{
			if (arr[i - 1] < arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
	else
		{
			if (arr[i - 1] > arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
}

static void check_sort_double(double arr[], int n, int DESC) {
	int i;
	for (i = 1; i < n; i++)

	if (DESC)
		{
			if (arr[i - 1] < arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
	else
		{
			if (arr[i - 1] > arr[i]) {
			fprintf(stderr, "internal sort algorithm error\n");
			exit(EXIT_FAILURE);
			}
		}
}

static void usage_and_exit(char *prgname) {
	printf("usage: %s SIZE\n", prgname);
	exit(EXIT_FAILURE);
}

static void print_array_int(int arr[], int size)
{
   int i;
   printf("\nSorted array:\n");
   for(i=0;i<size;i++)
      printf("%d\t",arr[i]);
}

static void print_array_float(float arr[], int size)
{
   int i;
   printf("\nSorted array:\n");
   for(i=0;i<size;i++)
      printf("%f\t",arr[i]);
}

static void print_array_double(double arr[], int size)
{
   int i;
   printf("\nSorted array:\n");
   for(i=0;i<size;i++)
      printf("%f\t",arr[i]);
}

static void any_key_wait()
{
	char cc;
	printf("\n...Press Any Key To Exit... \n");
	do
		{
			cc = getch();
		}
	while(!cc);
}

static void print_table_header()
	{
		gotoxy(0,2);
		printf("+=======================================================================+");
		gotoxy(0,3);
		printf("|Input array|Sort method|Data type  |No. compar.|No. swaps  |Elap. time |");
		gotoxy(0,4);
		printf("|-----------|-----------|-----------|-----------|-----------|-----------|");
	}

static void print_stats(char *sort_name, char *arr_type, int sorted) {
	unsigned long int swaps, comps;
	double time;
	int length_comps, length_swaps, length_time;

	if(strcmp(sort_name,"Bubble") == 0)
	{
		swaps = bubble_swap_count;
		comps = bubble_comp_count;
		time = bubble_time;
	}
	else if(strcmp(sort_name,"Insertion") == 0)
	{
		swaps = ins_swap_count;
		comps = ins_comp_count;
		time = ins_time;
	}
	else if(strcmp(sort_name,"Selection") == 0)
	{
		swaps = sel_swap_count;
		comps = sel_comp_count;
		time = sel_time;
	}
	else if(strcmp(sort_name,"Merge") == 0)
	{
		swaps = merge_swap_count;
		comps = merge_comp_count;
		time = merge_time;
	}

	length_comps = snprintf(0, 0, "%lu", comps);
	length_swaps = snprintf(0, 0, "%lu", swaps);
	length_time  = snprintf(0, 0, "%.0fms",time);

	gotoxy(0,goto_line);
	if (sorted==1) printf("|Unsorted   ");
	else if (sorted==2) printf("|ASC        ");
	else if (sorted==3) printf("|DESC       ");
	gotoxy(12,goto_line);
	printf("|%s",sort_name);gotoxy(24,goto_line); printf("|");
	gotoxy(25,goto_line);
	printf("%s",arr_type);	gotoxy(36,goto_line); printf("|");
	gotoxy(37+(11-length_comps),goto_line);
	printf("%lu",comps);	gotoxy(48,goto_line); printf("|");
	gotoxy(49+(11-length_swaps),goto_line);
	printf("%lu",swaps);	gotoxy(60,goto_line); printf("|");
	gotoxy(61+(11-length_time),goto_line);
	printf("%.0fms",time);	gotoxy(72,goto_line); printf("|");
	/*
	//Table lines between rows
	gotoxy(0,++goto_line);
	printf("|-----------+-----------+-----------+-----------+-----------+-----------|");
	*/
	goto_line++;
}

static void print_table_footer(){
	gotoxy(0,goto_line-1);
	printf("+=======================================================================+");
}

int main(int argc, char **argv) {
	int n;
	int *arr_int,*arr_int_temp;
	float *arr_float, *arr_float_temp;
	double *arr_double, *arr_double_temp;

	clear_screen();

	if (argc != 2)
	{
		 usage_and_exit(*argv);
	}


	srand((unsigned) time(NULL));

	n = atoi(argv[1]);
	if (n <= 0) {
		printf("SIZE has to be a positive number\n");
		return EXIT_FAILURE;
	}


	/* allocating memory for array */
	arr_int = calloc(n, sizeof(int));
	arr_int_temp = calloc(n, sizeof(int));
	arr_float = calloc(n, sizeof(float));
	arr_float_temp = calloc(n, sizeof(float));
	arr_double = calloc(n, sizeof(double));
	arr_double_temp = calloc(n, sizeof(double));

	printf("\nGenerating arrays with %d elements...\n",n);

	/* generating random array */
	fill_array_int(arr_int, n);
	memcpy(arr_int_temp, arr_int, sizeof(arr_int_temp));

	fill_array_float(arr_float, n);
	memcpy(arr_float_temp, arr_float, sizeof(arr_float_temp));

	fill_array_double(arr_double, n);
	memcpy(arr_double_temp, arr_double, sizeof(arr_double_temp));



	printf("Sorting started!");
	print_table_header();
	/* SORTING RANDOM ARRAY*/

	//print_array_int(arr_int, n);
	//print_array_float(arr_float, n);
	//print_array_double(arr_double, n);

	bubble_sort_int(arr_int, n);
		print_stats("Bubble","Integer",1);
	bubble_sort_float(arr_float, n);
		print_stats("Bubble","Float",1);
	bubble_sort_double(arr_double, n);
		print_stats("Bubble","Double",1);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	insertion_sort_int(arr_int, n);
		print_stats("Insertion","Integer",1);
	insertion_sort_float(arr_float, n);
		print_stats("Insertion","Float",1);
	insertion_sort_double(arr_double, n);
		print_stats("Insertion","Double",1);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));


	selection_sort_int(arr_int, n);
		print_stats("Selection","Integer",1);
	selection_sort_float(arr_float, n);
		print_stats("Selection","Float",1);
	selection_sort_double(arr_double, n);
		print_stats("Selection","Double",1);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	merge_sort_int(arr_int, n);
		print_stats("Merge","Integer",1);
	merge_sort_float(arr_float, n);
		print_stats("Merge","Float",1);
	merge_sort_double(arr_double, n);
		print_stats("Merge","Double",1);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);


	/* ARRAYS ARE IN ASCENDING ORDER!!! */

	/* SORTING ALREADY SORTED ARRAY */

	bubble_sort_int(arr_int, n);
		print_stats("Bubble","Integer",2);
	bubble_sort_float(arr_float, n);
		print_stats("Bubble","Float",2);
	bubble_sort_double(arr_double, n);
		print_stats("Bubble","Double",2);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	insertion_sort_int(arr_int, n);
		print_stats("Insertion","Integer",2);
	insertion_sort_float(arr_float, n);
		print_stats("Insertion","Float",2);
	insertion_sort_double(arr_double, n);
		print_stats("Insertion","Double",2);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	selection_sort_int(arr_int, n);
		print_stats("Selection","Integer",2);
	selection_sort_float(arr_float, n);
		print_stats("Selection","Float",2);
	selection_sort_double(arr_double, n);
		print_stats("Selection","Double",2);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	merge_sort_int(arr_int, n);
		print_stats("Merge","Integer",2);
	merge_sort_float(arr_float, n);
		print_stats("Merge","Float",2);
	merge_sort_double(arr_double, n);
		print_stats("Merge","Double",2);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	/* PREPARING ARRAYS
	 * sorting using insertion sort to generate DESC ordered arrays */

	ins_rev_dir = 1;
	insertion_sort_int(arr_int, n);
	insertion_sort_float(arr_float, n);
	insertion_sort_double(arr_double, n);
	ins_rev_dir = 0;

	check_sort_int(arr_int, n, 1);
	check_sort_float(arr_float, n, 1);
	check_sort_double(arr_double, n, 1);

	/* SORTING DESC ORDERED ARRAYS */

	bubble_sort_int(arr_int, n);
		print_stats("Bubble","Integer",3);
	bubble_sort_float(arr_float, n);
		print_stats("Bubble","Float",3);
	bubble_sort_double(arr_double, n);
		print_stats("Bubble","Double",3);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	insertion_sort_int(arr_int, n);
		print_stats("Insertion","Integer",3);
	insertion_sort_float(arr_float, n);
		print_stats("Insertion","Float",3);
	insertion_sort_double(arr_double, n);
		print_stats("Insertion","Double",3);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	selection_sort_int(arr_int, n);
		print_stats("Selection","Integer",3);
	selection_sort_float(arr_float, n);
		print_stats("Selection","Float",3);
	selection_sort_double(arr_double, n);
		print_stats("Selection","Double",3);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	memcpy(arr_int, arr_int_temp, sizeof(arr_int));
	memcpy(arr_float, arr_float_temp, sizeof(arr_float));
	memcpy(arr_double, arr_double_temp, sizeof(arr_double));

	merge_sort_int(arr_int, n);
		print_stats("Merge","Integer",3);
	merge_sort_float(arr_float, n);
		print_stats("Merge","Float",3);
	merge_sort_double(arr_double, n);
		print_stats("Merge","Double",3);

	check_sort_int(arr_int, n, 0);
	check_sort_float(arr_float, n, 0);
	check_sort_double(arr_double, n, 0);

	print_table_footer();

	printf("\nAll sorting finished successfully!");

	free(arr_int);
	free(arr_float);
	free(arr_double);

	// hold the window open
    //any_key_wait();

	return 0;
}