快速排序与冒泡，选择的比较

 

#include <stdio.h>
#include <time.h>
#include <windows.h>

//快速排序，参数是数组，最低索引，最高索引(从0开始)
void qSort(int a[], int low, int high){
	int temp;
	int mid = low;//定义一个中索引，用于记录一次排序后确定位置的一个元素索引
	int right = high;//记录最右元素索引
	
	//默认中值是左值，现在要把凡是比中值大的元素放到中值左边
	while(right > mid){//因此从右开始向中值遍历，到达中值时遍历结束
		if (a[right] < a[mid])//如果右值比中值还小，说明他不该在右边，要把它放到左边
		{
			temp = a[mid];//所以先把中值的地盘腾出来
			a[mid] = a[right];//把比中值小的那个数放在那儿
			//中值没地方放，必须右移移位，但是直接右移会覆盖原来他右边的那个值
			a[right] = a[++mid];//不过right索引的空间已经腾出来了，就把中值原来右边的值放到right
			a[mid] = temp;//然后就可以把mid右移一位
		}
		else{
			right--;//否则的话说明right已然大于等于mid，不用移动，继续判断right左边那个数
		}
	}//这样right与mid重合之时，退出循环，此时mid的位置已经确定了就是排完序后他的位置
	 //因为他左边的都比他小，右边的都比他大
	if (mid - low > 1)//如果low到mid之间还有两个或以上元素，还要对他们排序
	{
		qSort(a, low, mid - 1);
	}

	if (high - mid > 1)//右边那半也是一样
	{
		qSort(a, mid + 1, high);
	}
}

void sSort(int a[], int len){//选择排序，参数是数组名和元素个数
	int i, j, m, temp;
	for (i = 0; i < len - 1; i++)//从开始到倒数第二个元素
	{
		m = i;//先记录最左边的元素索引，假设他为最小
		for (j = i + 1; j < len; j++)//从左往右遍历一直到最后
		{
			if (a[j] < a[m])//如果发现更小的元素
			{
				m = j;//记下这个元素的索引
			}
		}
		if (m != i)//如果最小的元素不是开始那个，就需要把最小的换到最左边
		{
			temp = a[i];
			a[i] = a[m];
			a[m] = temp;
		}
	}
}

void mSort(int a[], int len){//冒泡法排序，参数是数组名，元素个数
	int i, j, temp;
	for (i = 0; i < len - 1; i ++)//从开始到倒数第二个元素
	{
		for (j = 0; j < len - 1 - i; j++)//从头遍历到已序队列往前第二个
		{
			if (a[j] > a[j + 1])//如果元素比他的后一个大，则交换
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}//一次遍历后最大元素放到最后面
	}
}

int checkSorted(int a[], int len){//检查数组排序是否已经正确
	int i;
	for (i = 0; i < len - 1; i++)
	{
		if (a[i] > a[i + 1])//如果一个元素比他的下一个还要大，说明发生错误
		{
			return 0;
		}
	}
	return 1;
}

void main(){
	int i, j;
	int a[99999];

	clock_t begin, end;
	double  cost;
	
	for (j = 0; j < 6; j++)//做6次测试
	{
		srand((int)time(0));//用时间做种，是每次数字都不同
		for (i = 0; i < 99999; i++)
		{
			a[i] = rand();//产生随机数放入数组
		}
		
		begin = clock();
		
		//qSort(a, 0, 99998);//1秒左右
		//sSort(a, 99999);//20秒左右
		mSort(a, 99999);//40秒左右
		
		end = clock();
		
		for (i = 0; i < 12; i++)//输出前面的几个排好序的元素
		{
			printf("%d ", a[i]);
		}

		cost =  (double)(end - begin) / CLOCKS_PER_SEC;//计算排序时间
		printf("...\t排序用时 %lf 秒 ", cost);//输出排序所用时间

		if (checkSorted(a, 99999))//检查排序是否正确
		{
			printf("正确!\n");
		}else{
			printf("有错!\n");
		}
		Sleep(1200);//暂停一下，使每次时间种子不同
	}
}

1. 快速排序的结果：

 99999个随机数一般不超过0.05秒，很快

2.选择法排序结果：

 一般在20多秒；

3.冒泡法，一般情况下交换的次数会很多，结果：

排序时间一般在50秒左右，最慢。

 

在C++中，还可以定义函数模板

因为快速排序通常很快，所以用它来对不同的数据类型排序

#include <iostream.h>

template<class T> void qSort(T a[], int low, int high){//在C++中，可以定义函数模板
	T temp;
	int mid = low;
	int right = high;

	while (right > mid)
	{
		if (a[right] < a[mid])
		{
			temp = a[mid];
			a[mid] = a[right];
			a[right] = a[++mid];
			a[mid] = temp;
		}else{
			right--;
		}
	}
	if (mid - low > 1)
	{
		qSort(a, low, mid - 1);
	}
	if (high - mid > 1)
	{
		qSort(a, mid + 1, high);
	}
}

void main(){
	int a[10] = {1, 9, 6, 3, 5, 7, 1};//有了一个函数模板，可以对整型排序
	qSort(a, 0, 9);
	for (int i = 0; i < 10; i++)
	{
		cout<<a[i]<<"  ";
	}
	cout<<endl;

	float b[10] = {2.0f, 1.2f, 5.5f, 6.63f, 9.11f, 1.32f, 3.44f, 5.0f, 5.22f, 0.02f};
	qSort(b, 0, 9);//对浮点数排序
	for (i = 0; i < 10; i++)
	{
		cout<<b[i]<<"  ";
	}
	cout<<endl;

	char c[10] = {'d','e','f','n','j','c','e','b','f','a'};//对字符数组排序
	qSort(c, 0, 9);
	for (i = 0; i < 10; i++)
	{
		cout<<c[i]<<"  ";
	}
	cout<<endl;
}//凡是可以用‘<’来比较大小的类型都可以排序了