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] );
}
}