C++

[wafty]

i want to help for "step counter" for merge sort and quick sort.... i want to print out how many steps it take to "random sorting ,reverse sorting and already sorted"

#include <iostream>
#include <functional>
#include <ctime>
#include <fstream>

using namespace std;

void RandomArray(int sort[], int size);
int NumberOfElements(int size);

void MergeSort(int sort[], int start, int end);
void Merge(int sort[], int start, int mid, int end);
void quickSort(int sort[], int start, int end);
void ArrayCopy(int sort[], int sortNew[], int size);
void ArrayReplace(int sort[], int sortNew[], int size);
void ReverseArray(int sort[], int size);
void printArray(int sort[], int size);


int main()
{
	int size, method;
	clock_t sec;

	size = NumberOfElements(size);        //Get size of Array
	int sort[size], sortNew[size];
	int start = 0, end = size - 1;
	RandomArray(sort, size);            //Generate random array
	ArrayCopy(sort, sortNew, size);     //Copy to another array


	cout << "Which sorting method would you like to use? ";

	while (method != 6)
	{
		cout << endl;
		
		cout << "Press 1 for Merge Sort: " << endl;
		cout << "Press 2 for Quick Sort: " << endl;

		cin >> method;

		switch (method)
		{
		case 1:
			
			cout << "Sort random array: \n";
			sec = clock();
			MergeSort(sort, start, end);        //Sorting random array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds \n" << endl;
			cout << "Sorted input data set: \n";
			sec = clock();
			MergeSort(sort, start, end);        //Sorting input data array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds \n" << endl;
			ReverseArray(sort, size);
			cout << "Sorting reverse array: \n";
			sec = clock();
			MergeSort(sort, start, end);        //Sort reversed array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds \n" << endl;
			printArray(sort, size);
			ArrayReplace(sort, sortNew, size);
			break;

		case 2:
			cout << "Sort random array: \n";
			sec = clock();
			quickSort(sort, start, end);        //Sorting random array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds \n" << endl;
			cout << "Sorted input data set: \n";
			sec = clock();
			quickSort(sort, start, end);         //Sorting input data array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds" << endl;
			ReverseArray(sort, size);
			cout << "Sorting reverse array: \n";
			sec = clock();
			quickSort(sort, start, end);        //Sort reversed array
			cout << "CPU clock time: " << (double)(clock() - sec) / CLOCKS_PER_SEC << " Seconds" << endl;
			printArray(sort, size);
			ArrayReplace(sort, sortNew, size);
			break;

		case 3:
			break;
		default: cout << "Wrong number entered! " << endl;

		}

	}
	return 0;
}



void RandomArray(int sort[], int size)
{
	for (int i = 0; i<size; i++)
	{
		bool check; //variable to check or number is already used
		int n; //variable to store the number in
		do
		{
			n = rand() % size;
			//check or number is already used:
			check = true;
			for (int j = 0; j<i; j++)
				if (n == sort[j]) //if number is already used
				{
					check = false; //set check to false
					break; //no need to check the other elements of value[]
				}
		} while (!check); //loop until new, unique number is found
		sort[i] = n; //store the generated number in the array
	}

}

void ArrayCopy(int sort[], int sortNew[], int size)
{

	for (int i = 0; i<size; i++)
	{
		sortNew[i] = sort[i];
	}

}

void ArrayReplace(int sort[], int sortNew[], int size)
{
	for (int i = 0; i<size; i++)
		sort[i] = sortNew[i];
}

void ReverseArray(int sort[], int size)
{
	int start = 0;
	int end = size - 1;
	while (start < end)
	{
		int temp = sort[start];
		sort[start] = sort[end];
		sort[end] = temp;
		start++;
		end--;
	}
}

int NumberOfElements(int size)
{
	int elements;

	cout << " Press 1 for 100 elements" << endl;
	cout << " Press 2 for 200 elements" << endl;
	cout << " Press 3 for 300 elements" << endl;
	cout << " Press 4 for 400 elements" << endl;
	cout << " Press 5 for 500 elements" << endl;
	cout << " Press 6 for 1000 elements" << endl;
	cout << " Press 7 for 2000 elements" << endl;
	cout << " Press 8 for 4000 elements" << endl;
	cout << " Press 9 for 10000 elements" << endl;

	cin >> elements;

	if (elements == 1)
		return 100;

	else if (elements == 2)
		return 200;

	else if (elements == 3)
		return 300;

	else if (elements == 4)
		return 400;

	else if (elements == 5)
		return 500;

	else if (elements == 6)
		return 1000;

	else if (elements == 7)
		return 2000;

	else if (elements == 8)
		return 4000;

	else if (elements == 9)
		return 10000;

	else
		cout << "Wrong selection!";
}




void MergeSort(int sort[], int start, int end)
{

	if (start<end)
	{
		int mid = (start + end) / 2;

		MergeSort(sort, start, mid);
		MergeSort(sort, mid + 1, end);
		Merge(sort, start, mid, end);
	}

}

void Merge(int sort[], int start, int mid, int end)
{
	int *temp = new int[end - start + 1];       //temporary merger array
	int i = start, j = mid + 1;             //i is for left-hand,j is for right-hand
	int k = 0;                              //k is for the temporary array

	while (i <= mid && j <= end)
	{
		if (sort[i] <= sort[j])
			temp[k++] = sort[i++];
		else
			temp[k++] = sort[j++];
	}

	//rest elements of left-half
	while (i <= mid)
		temp[k++] = sort[i++];

	//rest elements of right-half
	while (j <= end)
		temp[k++] = sort[j++];

	//copy the merged temporary array to the original array
	for (k = 0, i = start; i <= end; ++i, ++k)
		sort[i] = temp[k];

	delete[]temp;
}

void quickSort(int sort[], int start, int end)
{

	int i = start, j = end;

	int tmp;

	int pivot = sort[(start + end) / 2];

	/* partition */

	while (i <= j)
	{

		while (sort[i] < pivot)

			i++;

		while (sort[j] > pivot)

			j--;

		if (i <= j)
		{
			tmp = sort[i];

			sort[i] = sort[j];

			sort[j] = tmp;

			i++;

			j--;
		}
	};
	/* recursion */
	if (start < j)
		quickSort(sort, start, j);
	if (i < end)
		quickSort(sort, i, end);

}

void printArray(int sort[], int size)
{
	cout << "Sorted array: ";
	for (int i = 0; i < size; i++)
		cout << sort[i] << ", ";
	cout << endl;
}

[MikeyBoy]

Add an integer variable to each sort function, and increment it for every step.

Either have the sort function print out the number of steps, or else have those functions return the number of steps to the calling code, so the calling code can print it out.