选择排序和冒泡排序的比较

1.选择排序的平均时间复杂度比冒泡排序的稍低:
2.同样数据的情况下，2种算法的循环次数是一样的，但选择排序只有0到1次交换，而冒泡排序有0到n次交换

以下是自己写的代码，可以方便修改数据的个数，然后比较两种算法所使用的时间：

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#define  MAX_SIZE 10000
#define  SWAP(x,y,t) ((t) = (x),(x) = (y),(y) = (t))

void SelectSort(int iList[],int iNum );
void BubleSort(int iList[],int iNum );

int main()
{
	srand(time(0));
	int iNum = 0;
 	while(1)
 	{
 		printf("输入要排序的数字的个数:1----9999\n");
 		scanf("%d",&iNum);
 		if (iNum > MAX_SIZE || iNum < 0)
 		{
 			printf("输入的数字有误，请从新输入\n");
 		}
 		else
 		{
 			break;
 		}
 	}

	//生成要排序的数
	printf("\n----------------随机生成选择排序的数----------------\n");
	int i;
	int iList[MAX_SIZE];
	for (i = 0; i < iNum; ++i)
	{
		iList[i] = rand()%MAX_SIZE;
		printf("%d ",iList[i]);
	}

	//使用选择排序
	clock_t tSelectStart = clock();
	SelectSort(iList,iNum);
	clock_t tSelectEnd   = clock();
	//输出排序之后的数
	printf("\n----------------使用选择排序产生的结果------------------\n");
	for (i = 0; i < iNum; ++i)
	{
		printf("%d ",iList[i]);
	}

	printf("\n----------------随机生成冒泡排序的数----------------\n");
	for (i = 0; i < iNum; ++i)
	{
		iList[i] = rand()%MAX_SIZE;
		printf("%d ",iList[i]);
	}
	
	clock_t tBubleStart = clock();
	BubleSort(iList,iNum);
	clock_t tBubleEnd = clock();
	printf("\n----------------使用冒泡排序产生的结果---------------------\n");
	//输出排序之后的数
	for (i = 0; i < iNum; ++i)
	{
		printf("%d ",iList[i]);
	}
	printf("\n选择排序一共使用时间%d:ms\n",tSelectEnd - tSelectStart);
	printf("\n冒泡排序一共使用时间%d:ms\n",tBubleEnd - tSelectEnd);
	system("pause");
	return 0;
}

//冒泡排序算法
void BubleSort(int iList[],int iNum )
{
	int i,j,iTemp;
	for (i = 0; i < iNum-1; ++i)
	{
		for (j = 0 ; j < iNum-i-1;++j)
		{
			if (iList[j] > iList[j+1])
			{
				SWAP(iList[j],iList[j+1],iTemp);
			}
		}
	}
}
//选择排序算法
void SelectSort(int iList[],int iNum)
{
	int i,j,iTemp,iMin;
	for (i = 0 ; i < iNum-1 ; ++i )
	{	
		iMin = i;
		for (j = i + 1; j < iNum ;j++)
		{
			if (iList[iMin] > iList[j])
			{
				iMin = j;
			}
		}
		SWAP(iList[i],iList[iMin],iTemp);
	}
}

运行结果：可以看出选择排序效率还是比冒泡高不少，如果数据量足够大，差距更明显，你可以自己试试，博主用少量的数据只是为了方便观看^_^

以下是某个妹子写的C++算法，看了我只有膜拜的功夫了：

template <class T>
void bubble_sort( T a[], int n )
{ // 稳定的排序

	// 交换标志exchanged,我们希望用这个标志减少不必要的扫描.
	// 当它为真时,表明交换之前数组无序,但我们也不能确保在交换之后数组每一个
	// 元素都排到有序状态下的正确位置了,所以再对数组进行扫描是必要的.
	// 当它为假时,表明数组有序了,不必再对数组进行扫描了.
	bool exchange = true; // 算法开始前,自然假设数组无序
	for( int i = n - 1; i > 0 && exchange; --i ) { // 最多做n-1趟扫描
		exchange = false; // 在一趟扫描开始前,我们总假设这趟扫描是不必要的
		for( int j = 0; j < i; ++j ) { // 对当前无序区a[0:i]进行扫描
			if( a[j+1] < a[j] ) {
				std::swap( a[j+1], a[j] ); // 大的往下沉,而小的往上冒
				exchange = true; // 发生了交换,故将交换标志置为真
			}
		}
	}
}

template <class T>
void selection_sort( T a[], int n )
{ // 不稳定; 反例: { 2, 2, 1 }
	int min;
	for( int i = 0; i < n - 1; ++i ) { // 最多做n-1趟排序
		min = i; // 先假设a[i]最小
		for( int j = i + 1; j < n; ++j ) // 在当前无序区a[i:n-1]中查找最小值
			if( a[j] < a[min] )
				min = j; // min记下当前无序区最小值所在位置
		if( min != i ) // 找到比当前a[i]更小者
			std::swap( a[i], a[min] );
	}
}