1.十大排序算法复杂度
中文名称 | 英文名称 | 平均时间复杂度 | 稳定性 |
---|---|---|---|
选择排序 | Selection | n 2 n^2 n2 | 不稳定 |
冒泡排序 | Bubble | n 2 n^2 n2 | 稳 |
插入排序 | Insertion | n 2 n^2 n2 | 稳 |
堆排序 | heap | n l o g 2 n n{log_2{n}} nlog2n | 不稳 |
希尔排序 | Shell | n 1.3 n^{1.3} n1.3 | 不稳 |
归并排序 | Merge | n l o g 2 n n{log_2{n}} nlog2n | 稳 |
快速排序 | Quick | n l o g 2 n n{log_2{n}} nlog2n | 不稳 |
桶排序 | Bucket | n+k | 稳 |
计数排序 | Counting | n+k | 稳 |
基数排序 | Radix | n*k | 稳 |
记忆法:转自马士兵
选泡插,
快归堆希桶计基
恩方恩老恩一三
对恩加K恩乘K,(对:指桶排序和计数排序一对)
不稳稳稳不稳稳,
不稳不稳稳稳稳,
2、选择排序
最没用的算法,时间复杂度高,还不稳定。
基本思想:从给定的数中选择出最大(或最小)的数,将其放在第一个位置;再从剩下的数中选择出最大(或最小)的数,将其放在第二个位置。以此类推!
void selectSort(int arry[],int len)
{
for (int i = 0; i < len-1; i++)
{
int minpos = i; //记录最小数的位置
for (int j = i+1; j < len; j++)
{
minpos = arry[j]<arry[minpos]?j:minpos;
}
swap(arry[i],arry[minpos]);
}
}
简单优化版:每次外层的循环后找出最大值和最小值,将小值放在第一位,将最大值放在最后一位;对剩下的元素同样找出最大值和最小值,将最小值放在第二位,最大值放在倒数第二位;依次类推,直至排序结束。可以将外层的for循环次数减半。
//优化版:每次同时找出最大值和最小值,减少遍历的次数
//写的时候注意循环的边界条件
void selectSort(int arry[],int len)
{
for (int i = 0; i != len/2; i++)
{
int minpos = arry[i]>arry[i+1]?i+1:i; //记录最小数的位置
int maxpos = arry[i]<arry[i+1]?i+1:i; //记录最大数的位置
for (int j = i+2; j < len-i; j++)
{
minpos = arry[j]<arry[minpos]?j:minpos;
maxpos = arry[j]>arry[maxpos]?j:maxpos;
// cout<<"j = "<<j<<endl;
}
// cout<<"max:"<<arry[maxpos]<<" "<<"min:"<<arry[minpos]<<endl;
swap(arry[i],arry[minpos]);
swap(arry[len-i-1],arry[maxpos]);
// PrintfArry(arry,len);
}
}
3、冒泡排序
基本思想 :从给定的数中选出最大的数,放在数组末尾;在剩下的数中在选出最大的数,放在数组倒数第二位。以此类推。
void BubbleSort(int arry[],int len)
{
int i,j;
/* 外循环为排序趟数,len个数进行len-1趟 */
for (i = 0; i < len-1; i++)
{
/* 内循环为每趟比较的次数,第i趟比较len-i次 */
for (j = 0; j < len-1-i; j++)
{
if(arry[j]>arry[j+1])
{
int temp = arry[j];
arry[j] = arry[j+1];
arry[j+1] = temp;
}
}
}
}
简单优化改良版:如果给定的数是有序的,或者经过几次排序后剩下的数是有序的,使用上面的算法就会造成时间的浪费。可以加个标志,如果经过某几次排序后剩下的为有序的话,就不会进入里面的swap所在的if块,那么剩下的也没必要在继续排了。
void Bubblesort(vector<int> &arr)
{
int len = arr.size();
for (int i = 0; i < len-1; i++)
{
bool state = true; //假设剩下的序列有序
for (int j = 0; j < len-i-1; j++)
{
if(arr[j]>arr[j+1])
{
//进入里面说明无序,还需要交换位置
state = false;
swap(arr[j],arr[j+1]);
}
}
if(state) //如果剩下的有序,那么state就不会被置位false。剩下的也没必要继续进行排序了
break;
}
}
4、插入排序
基本思想:类似于打扑克牌时,将待排序的数在已经排序好的数中选择合适的位置插入
void insertSort(int arr[],int len)
{
for (int i = 0; i < len; i++)
{
for (int j = i; j > 0; j--)
{
if(arr[j-1]>arr[j])
swap(arr[j-1],arr[j]);
}
}
}
简易优化版:上述方法会额外的调用swap方法,造成时间的浪费。下面是简单优化。将待排序的数用一个临时变量保存,为待排序的数选择合适位置插入,在插入之前每次将前一个数后一个位置移动。
void insertSort(int arr[],int len)
{
int i =0, j=0;
for (i = 0; i < len; i++)
{
int temp = arr[i];
for (j = i-1; j >= 0; j--)
{
if(arr[j]>temp)
{
arr[j+1] = arr[j];
}
else
break;
}
arr[j+1] = temp;
}
}
5、希尔排序
希尔排序是一种递减增量排序方法,是插入排序的改进版。
基本思想 :先选择一个步长增量,对原始数据按照步长gap分组。对每组内的数据进行插入排序;在减小步长,再次按照步长进行分组,对每组内的数据进行插入排序。直至步长变为1进行,进行最后的插入排序。
步长的选择:采用Kunth序列来确定步长是比较高效的选择。
Kunth序列:h=3*h+1(h=1)
void shellsort(vector<int> &v)
{
//选择步长
int h = 1;
while (h <= v.size()-1)
{
h = h*3+1;
}
for(int step = h ; step > 0; step = (step-1)/3)
{
//下面还是插入排序
for(int i = step; i<v.size(); i++)
{
for (int j = i; j>step-1; j-= step)
{
if(v[j] < v[j-step])
swap(v[j], v[j-step]);
}
}
}
}