冒泡排序和选择排序

    冒泡排序在很多计算机入门课程中作为例题介绍给初学程序设计者，这其实价值不大，一方面冒排相对较慢，另一方面也没有插入排序容易理解，不过冒排也是简单粗暴的。下面要介绍的是最naïve的冒排，还有稍作优化一点的冒泡，最后在介绍冒排的变体，也就是选择排序。

    原理：在每轮外循环i中，从数组底部开始，跟相邻的低序的元素比较，如果是升序数组，当低序的元素值比高序的元素的值大，则交换两者的值；将这种比较和交换的操作落实到内循环的每一次循环，这样每次都能使第I小的元素像“冒泡”一样浮到数组的最上面。由于在每次外循环中，执行内循环的次数为n，故整个冒排的复杂度为O(n^2)。代码有注释。

#include <iostream>
#include <Windows.h>
using namespace std;

void swap(int arr[], int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

double bubbleSort1(int arr[], int size) {
	LARGE_INTEGER stime;
	LARGE_INTEGER etime;
	LARGE_INTEGER freq;

	int pass;
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&stime);
	for(pass = 0; pass < size - 1; pass++) {	//每次外循环的含义就是找第pass小的数
		for(int i = size - 1; i > pass; i--) {	//pass及其之前的数组已经有序，比较数组末尾到pass+1的元素，通过交换位置找到第pass+1小的值
			if(arr[i] < arr[i-1]) {
				swap(arr, i, i-1);
			}
		}
	}
	QueryPerformanceCounter(&etime);

	return 1000.0*(etime.QuadPart - stime.QuadPart)/freq.QuadPart;
}

double bubbleSort2(int arr[], int size) {
	LARGE_INTEGER stime;
	LARGE_INTEGER etime;
	LARGE_INTEGER freq;

	int pass;
	int flag;
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&stime);
	for(pass = 0; pass < size - 1; pass++) {
		flag = 1;	//在每轮外循环中，将该标记设置为1
		for(int i = size - 1; i > pass; i--) {
			if(arr[i] < arr[i-1]) {
				swap(arr, i, i-1);
				flag = 0;
			}
		}
		if(flag)	//如果在该轮外循环中，遍历了一边内循环后该标记没被修改过，说明已经数组有序，后面的外循环都不需要执行，直接break出循环体
			break;
	}
	QueryPerformanceCounter(&etime);

	return 1000.0*(etime.QuadPart - stime.QuadPart)/freq.QuadPart;
}

double selectSort(int arr[], int size) {
	LARGE_INTEGER stime;
	LARGE_INTEGER etime;
	LARGE_INTEGER freq;

	int pass;
	int index;
	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&stime);
	for(pass = 0; pass < size - 1; pass++) {
		index = pass;
		for(int i = size - 1; i > pass; i--) {
			if(arr[index] > arr[i])
				index = i;	//用index来保存在第pass次外循环中找到的最小的值
		}
		swap(arr, index, pass);	//然后放在正确的位置
	}
	QueryPerformanceCounter(&etime);

	return 1000.0*(etime.QuadPart - stime.QuadPart)/freq.QuadPart;
}

int main()
{
	/*int arr[] = {14,4,84,51,7,65,13,90,87,5,6,8,41,333,56,42};
	selectSort(arr,sizeof(arr)/sizeof(int));
	for(int i = 0; i< sizeof(arr)/sizeof(int); i++)
		cout<<arr[i]<<" ";
	cout<<endl;*/
	const int len = 10000;

	int pass = 10;
	double sum1 = 0;
	double sum2 = 0;
	while(pass--) {
		int *arr1 = new int [len];
		int *arr2 = new int [len];
		for(int i = 0; i < len; i++)
			arr1[i] = arr2[i] = i;

		sum1 += bubbleSort2(arr1,len);
		sum2 += selectSort(arr2,len);
	}

	cout<<"sort1 aveTime: "<<sum1/10<<"ms"<<endl;
	cout<<"sort2 aveTime: "<<sum2/10<<"ms"<<endl;
}

    在测试中，使用倒序数据对两种冒泡排序算法进行测试，两者的平均运行时间是非常接近的，因为对于倒序的数据，优化后的冒排中的flag标志根本没起什么作用。但是对于基本有序，或者已经有序的数组，假设是[3,4,5,6,7,8,9,10,1,2]，那么算法1还是要执行n外循环，而算法2执行了2两次外循环后就结束了。

    在测试1中，对冒排1和冒排2使用了倒序数组测试，两者并无明显差异；但使用排好序的数组来测试两者，后者基本不用时间，因为执行了第一轮外循环就退出了，而冒排1使用时间主要用在n^2次比较。

图1 冒排1和冒排2测试有序数组的耗时

    选择排序本质上是冒排排序，但是并不急着做交换， 而是每一轮外循环中即系当轮循环要寻找的最小的数的下标，待内循环执行完毕再将该数放置在正确的位置。因此，选择排序相比冒泡排序减少了很多次交换的操作，性能优于冒泡排序。图2是测试冒排1和选择排序时候的耗时对比（测试数组是倒序或者有序对本次测试无影响）。

图2 冒泡排序和选择排序耗时对比

另外几者的比较在这里能看到，特别是对稳定算法和不稳定算法的描述，言简意赅。