C语言四种主要排序算法的实例比较

按要求生成随机数，然后用快速排序、桶排序、堆排序、归并排序四种算法分别记录排序时间。 

#include <fstream>
#include <iostream>
#include<ctime>
#include<time.h>

using namespace std;


int * loadTxt(string fileName, int *data);
int writeTxt(string fileName, int *data);
int * getRandom(int min, int max);
void quickSort(int *data, int left, int right);
void bucketSort(int *data, int min, int max);
void swap(int *a, int *b);
void heapAdjust(int * data, int left, int right);
void heapSort(int * data);
void mergeSort(int * data, int left, int right);


int length = 0;  //定义全局变量，数据个数初始化为0

int main()
{
	int * data = new int[1000000];
	string fileName;
	clock_t startTime, endTime;

	fileName = "随机数.txt";

	int min = 1;
	int max = 1234567;

	
	//生成区间[min, max]范围内指定数目length个随机数，并保存为文件
	length = 700000; 
	data = getRandom(min, max);
	writeTxt(fileName, data);
	

	data = loadTxt(fileName, data);  //读取随机数文件
	//使用快速排序法排序
	cout << "快速排序法：" << endl;
	cout << "数据个数：" << length << endl;
	cout << "数据区间：[" << min << ", " << max << "]" << endl;
	startTime = clock();
	cout << "开始时间：" << startTime << endl;
	quickSort(data, 0, length - 1);
	endTime = clock();
	cout << "结束时间：" << endTime << endl;
	cout << "总共花费时间：" << endTime - startTime << endl << endl;
	
	data = loadTxt(fileName, data);  //读取随机数文件
	//使用桶排序法排序
	cout << "桶排序法：" << endl;
	cout << "数据个数：" << length << endl;
	cout << "数据区间：[" << min << ", " << max << "]" << endl;
	startTime = clock();
	cout << "开始时间：" << startTime << endl;
	bucketSort(data, min, max + 1);
	endTime = clock();
	cout << "结束时间：" << endTime << endl;
	cout << "总共花费时间：" << endTime - startTime << endl << endl;
	
	data = loadTxt(fileName, data);  //读取随机数文件
	//使用堆排序法排序
	cout << "堆排序法：" << endl;
	cout << "数据个数：" << length << endl;
	cout << "数据区间：[" << min << ", " << max << "]" << endl;
	startTime = clock();
	cout << "开始时间：" << startTime << endl;
	heapSort(data);
	endTime = clock();
	cout << "结束时间：" << endTime << endl;
	cout << "总共花费时间：" << endTime - startTime << endl << endl;
	
	data = loadTxt(fileName, data);  //读取随机数文件
	//使用归并排序法排序
	cout << "归并排序法：" << endl;
	cout << "数据个数：" << length << endl;
	cout << "数据区间：[" << min << ", " << max << "]" << endl;
	startTime = clock();
	cout << "开始时间：" << startTime << endl;
	mergeSort(data, 0, length);
	endTime = clock();
	cout << "结束时间：" << endTime << endl;
	cout << "总共花费时间：" << endTime - startTime << endl << endl;

	//把排序结果保存为文件
	fileName = "排序输出.txt";
	writeTxt(fileName, data);

	system("pause");
	return 0;
}

int * loadTxt(string fileName, int *data)
{
	ifstream infile(fileName);
	if (infile.is_open()) //如果文件正确打开
	{
		int i = 0;
		while (!infile.eof())  //如果文件没有结束
		{
			infile >> data[i];
			i++;
		}
		length = i - 1;  //数据个数
		infile.close();
	}
	else
	{
		cout << "读取文件没找到!" << endl;
	}
	return data;
}

int writeTxt(string fileName, int *data)
{
	ofstream outfile(fileName);
	for (int i = 0; i < length; i++)
	{
		outfile << data[i] << "\n";
	}
	outfile.close();
	return 0;
}

int * getRandom(int min, int max)
/*
生成区间[min, max]范围内的length个随机数
*/
{
	int * data = new int[length];
	srand((unsigned int)time(NULL));
	for (int i = 0; i < length; i++)
	{
		data[i] = (rand() * rand()) % (max - min + 1) + min;
	}
	return data;
}

void quickSort(int *data, int left, int right)
/*
快速排序法：对数组 data 进行排序，排序区间为数组下标 [left, right] 左开右开区间
*/
{
	if (left < right)
	{
		int i = left, j = right, x = data[left];
		while (i < j)
		{
			while (i < j && data[j] > x) // 从右向左找第一个小于x的数
				j--;
			if (i < j)
				data[i++] = data[j];
			while (i < j && data[i] < x) // 从左向右找第一个大于等于x的数
				i++;
			if (i < j)
				data[j--] = data[i];
		}
		data[i] = x;
		quickSort(data, left, i - 1); // 递归调用
		quickSort(data, i + 1, right);
	}
}

void bucketSort(int *data, int min, int max)
/*
桶排序法：对数组 data 进行排序，数据的最小值为 min 最大值为 max ，随机数个数为 length ，数值区间范围值 max - min 越小效率较高
*/
{
	int i, j;
	int * buckets = new int [max - min +1];  //按照区间[min, max]建立辅助数组，桶的个数为max-min+1个，min对应buckets[0]
	memset(buckets, 0, (max - min) * sizeof(int));  //数组元素全部归零
	for (i = 0; i < length; i++)
	{
		buckets[data[i] - min + 1]++;  //对随机数组中的数据进行计数
	}
	for (i = 0, j = 0; i <= (max - min); i++)
	{
		while ((buckets[i]--) > 0)  //按照计数器的值把相应个数的数据
			data[j++] = i;
	}
	delete[] buckets;  //释放辅助数组内存
}

void swap(int *a, int *b)
/*
该函数用于交换两个变量的值
*/
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

void heapAdjust(int * data, int left, int right)
/*
堆调整，将数组 data 下标区间为 [left,right] 之间的元素调整为最大堆
*/
{
	int temp = data[left];
	int parent = left;
	int child;
	while (2 * parent + 1 <= right)
	{
		child = 2 * parent + 1;
		if (child != right && data[child] < data[child + 1])
		{
			child++;
		}
		if (temp > data[child])
		{
			break;
		}
		else
		{
			data[parent] = data[child];
		}
		parent = child;
	}
	data[parent] = temp;
}

void heapSort(int * data)
/*
堆排序：根节点序号为0
*/
{
	for (int i = length / 2; i >= 0; i--)  //调整整个二叉树为最大堆
		heapAdjust(data, i, length - 1);
	for (int i = length - 1; i > 0; i--)
	{
		swap(&data[0], &data[i]);
		heapAdjust(data, 0, i - 1);
	}
}


void mergeSort(int * data, int left, int right)
/*
归并排序法：对数组 data 进行排序，排序区间为数组下标 [left, right) 左开右闭区间
*/
{
	if (left + 1 >= right)
	{
		return;
	}
	else
	{
		int middle = (left + right) / 2;
		mergeSort(data, left, middle);
		mergeSort(data, middle, right);

		int * auxArray = new int[right - left + 1];
		int i = 0;
		int j = 0;
		int k = 0;
		while (left + k < right)
		{
			if (left + i < middle)
			{
				if (middle + j < right)
				{
					if (data[left + i] <= data[middle + j])
					{
						auxArray[k] = data[left + i];
						i++;
					}
					else
					{
						auxArray[k] = data[middle + j];
						j++;
					}
				}
				else
				{
					auxArray[k] = data[left + i];
					i++;
				}
			}
			else
			{
				auxArray[k] = data[middle + j];
				j++;
			}
			k++;
		}
		for (i = 0; i < k; i++)
		{
			data[left + i] = auxArray[i];
		}
		delete[] auxArray;
		return;
	}
}