C++基于比较的排序算法实现

#include <iostream>
#include <algorithm>
#include <time.h>

using namespace std;

void swap(int *arr, int m, int n);
void printArray(int *arr, int size);
int *generateRandomArray(int maxSize, int maxValue, int &size);
bool isEqual(int firstArr[], int secondArr[], int size);
int *copyArray(int oldArray[], int size);
void comarator(int *arr, int size);

//插入排序
void insertionSort(int *arr, int size);
//希尔排序
void shellSort(int *arr, int size);
void groupSort(int* a, int n, int i, int gap);
//选择排序
void selectionSort(int *arr, int size);
//堆排序
void heapInsert(int *arr, int index);
void heapify(int *arr, int index, int size);
void heapSort(int *arr, int size);
//冒泡排序
void bubbleSort(int *arr, int size);
//快速排序
void quickSort(int *arr, int size);
void quickSort(int *arr, int size, int l, int r);
int partition(int *arr, int size, int l, int r);
//归并排序
void mergeSort(int *arr, int size);
void mergeSort(int *arr, int size, int l, int r);
void merge(int *arr, int size, int l, int mid, int r);


bool forTest = false;
int srandNum1 = 0;
int srandNum2 = 100;


int main()
{
	if (!forTest)
	{
		int size = 0;
		int testTime = 5000;
		int maxSize = 10;
		int maxValue = 10;
		bool succeed = true;
		for (int i = 0; i < testTime; i++)
		{
			int *arr1 = generateRandomArray(maxSize, maxValue, size);
			int *arr2 = copyArray(arr1, size);
			mergeSort(arr1, size);
			comarator(arr2, size);
			if (!isEqual(arr1, arr2, size))
			{
				succeed = false;
				printArray(arr1, size);
				printArray(arr2, size);
				break;
			}
		}
		if (succeed)
		{
			cout << "Nice!" << endl;
		}
		else
		{
			cout << "Fucking Fucked" << endl;
		}
	}
	else
	{
		int arr[5] = { 6,4,9,5,7 };
		mergeSort(arr, 5);
		printArray(arr, 5);
	}
	system("pause");
	return 0;
}

void swap(int *arr, int m, int n)
{
	int temp = arr[m];
	arr[m] = arr[n];
	arr[n] = temp;

	//arr[m] = arr[m] ^ arr[n];
	//arr[n] = arr[m] ^ arr[n];
	//arr[m] = arr[m] ^ arr[n];

}

void printArray(int *arr, int size)
{
	for (int i = 0; i < size; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

int *generateRandomArray(int maxSize, int maxValue, int &size)
{
	srandNum1 += 3;
	srandNum2++;
	srand((unsigned)time(NULL)*srandNum1*srandNum1*srandNum2*srandNum2*srandNum2);
	size = (int)(rand() % (maxSize)+1);

	int *arr = new int[size];
	for (int i = 0; i < size; i++)
	{
		//arr[i] = ((rand() % (2 * maxValue)) - maxValue);
		arr[i] = (rand() % maxValue);
	}
	//printArray(arr, size);
	return arr;
}

void comarator(int *arr, int size)
{
	sort(arr, arr + size);
	//sort类函数
	//sort(begin，end，cmp):cmp参数省缺时进行升序排序
	//		cmp参数使用类模板：less<data - type>()升序；greater<data-type>()降序。
	//stable_sort:对指定区间进行稳定排序
	//is_sorted:判断一个区间是否已经排好序
}

int *copyArray(int oldArray[], int size)
{
	if (size == 0)
	{
		return nullptr;
	}
	int *newArray = new int[size];
	for (int i = 0; i < size; i++)
	{
		newArray[i] = oldArray[i];
	}
	return newArray;
}

bool isEqual(int firstArr[], int secondArr[], int size)
{
	if (size == 0)
	{
		return true;
	}
	for (int i = 0; i < size; i++)
	{
		if (firstArr[i] != secondArr[i])
		{
			return false;
		}
	}
	return true;
}

void insertionSort(int *arr, int size)
{
	if (size == 0 || size == 1)
	{
		return;
	}
	for (int i = 0; i < size; i++)
	{
		for (int j = i; j > 0; j--)
		{
			if (arr[j-1]>arr[j])
			{
				swap(arr, j - 1, j);
			}
		}
	}
}

void shellSort(int *arr, int size)
{
	for (int gap = size / 2; gap > 0; gap /= 2)
	{
		// 共gap个组，对每一组都执行直接插入排序
		for (int i = 0;i < gap; i++)
		groupSort(arr, size, i, gap);
	}
}

void groupSort(int* arr, int size, int i, int gap)
{
	for (int j = i + gap; j < size; j += gap)
	{
		for (int k = j; k > i ; k-= gap)
		{
			if (arr[k - gap]>arr[k])
			{
				swap(arr, k - gap, k);
			}
		}
	// 如果a[j] < a[j-gap]，则寻找a[j]位置，并将后面数据的位置都后移。
		//if (arr[j] < arr[j - gap])
		//{
		//	int tmp = arr[j];
		//	int k = j - gap;
		//	while (k >= 0 && arr[k] > tmp)
		//	{
		//		arr[k + gap] = arr[k];
		//		k -= gap;
		//	}
		//	arr[k + gap] = tmp;
		//}
	}
}

void selectionSort(int *arr, int size)
{
	if (size == 0 || size == 1)
	{
		return;
	}
	int min = 65535;
	int minIndex = 0;
	for (int i = 0; i < size; i++)
	{
		for (int j = i; j < size; j++)
		{
			if (arr[j] < min)
			{
				min = arr[j];
				minIndex = j;
			}
		}
		swap(arr, i, minIndex);
		min = 65535;
	}
}

void bubbleSort(int *arr, int size)
{
	if (size == 0 || size == 1)
	{
		return;
	}
	for (int i = size-1; i >0; i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (arr[j + 1] < arr[j])
			{
				swap(arr, j + 1, j);
			}
		}
	}

}

void heapInsert(int *arr, int index)
{
	while (arr[index]>arr[(index - 1) / 2])
	{
		swap(arr, index, (index - 1) / 2);
		index = (index - 1) / 2;
	}
}

void heapify(int *arr, int index, int heapSize)
{
	int left = 2 * index + 1;
	while (left < heapSize)
	{
		int maxIndex;
		if ((left + 1 < heapSize) && (arr[left + 1] > arr[left]))
		{
			maxIndex = left + 1;
		}
		else
		{
			maxIndex = left;
		}
		//注意下面这段代码，自己写的时候忘记加了，导致错误。
		maxIndex = arr[maxIndex] > arr[index] ? maxIndex : index;
		if (maxIndex == index)
		{
			break;
		}

		swap(arr, index, maxIndex);
		index = maxIndex;
		left = 2 * index + 1;
	}
}

void heapSort(int *arr, int size)
{
	if (size == 1)
	{
		return;
	}
	for (int i = 0; i < size; i++)
	{
		heapInsert(arr, i);
	}

	//printArray(arr, size);
	swap(arr, 0, --size);
	while (size>0)
	{
		heapify(arr, 0, size);
		swap(arr, 0, --size);
	}
}

void mergeSort(int *arr, int size)
{
	if (size ==0 || size==1)
	{
		return;
	}
	mergeSort(arr, size, 0, size - 1);
}

void mergeSort(int *arr, int size, int l, int r)
{
	if (l == r)	return;
	int mid = (l + r) / 2;
	mergeSort(arr, size, l, mid);
	mergeSort(arr, size, mid + 1, r);
	merge(arr, size, l, mid, r);
}

void merge(int *arr, int size, int l, int m, int r)
{
	int num = r - l + 1;
	int *help = new int[num];
	int i = 0;
	int p1 = l;
	int p2 = m + 1;
	while (p1 <= m && p2 <= r)
	{
		help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
	}
	while (p1 <= m)
	{
		help[i++] = arr[p1++];
	}
	while (p2 <= r)
	{
		help[i++] = arr[p2++];
	}
	for (i = 0; i < num; i++)
	{
		arr[l + i] = help[i];
	}
	delete[] help;
}

void quickSort(int *arr, int size)
{
	if (size == 0 || size ==1)
	{
		return;
	}
	quickSort(arr, size, 0, size - 1);
}

void quickSort(int *arr, int size, int low, int high)
{
	if (low < high)
	{
		int q = partition(arr, size, low, high);
		quickSort(arr, size, low, q - 1);
		quickSort(arr, size, q + 1, high);

	}
}

int partition(int *arr, int size, int low, int high)
{
	int pivot = arr[high];//拿最后一个数进行划分
	int mid = low;//小于区域的下一个数
	for (int i = low; i < high + 1; i++)
	{
		if (arr[i] < pivot)	swap(arr, i, mid++);
	}
	swap(arr, mid, high);
	return mid;
}