一些基本的概念
排序的稳定性:就是排序前可能有两个相同值的数字,K1,K2他们的位置是K1在前K2在后,如果排序后还是同样的顺序K1,K2,则称该排序算法是稳定的,否则是不稳定的
内部排序:指的是待排 序记录全部存放在计算机内存中进行排序的过程
外部排序:指的是待排序记录的数 量很大,以致内存一次不能容纳全部记录,在排序过程中尚需对外存进行访问的排序过程。
插入排序
插入排序的基本思想是:每一趟将一个待排序的记录,按其关键字的大小插入已经排好序 的一组记录的适当位置,直到所有待排序记录全部插入为止。
直接插入排序
void InsertSort(SqList &L)
{//对顺序表L进行直接插入排序
for(i=2;i<=L.length;++i)
if(L.r[i].key<L.r[i-1].key) //“<”,需将r[i]插入有序子表
{
L.r[0]=L.r[i]; //将待插入的记录暂存到监视哨中
L.r[i]=L.r[i-1]; //r[i-1]后移
for(j=i-2; L.r[0].key<L.r[j].key; --j) //从后向前寻找插入位置
L.r[j+1]=L.r[j]; //记录逐个后移,直到找到插入位置
L.r[j+1]=L.r[0]; //将r[0]即原r[i],插入正确位置
} //if
}
算法的时间复杂度O(n^2)
空间复杂度O(1)
【算法特点】
(1)稳定排序。
(2)算法简便,且容易实现。
(3)也适用于链式存储结构,只是在单链表上无须移动记录,只需修改相应的指针。
(4)更适合于初始记录基本有序(正序)的情况,当初始记录无序、n较大时,此算法时 间复杂度较高,不宜采用。
折半插入排序
void BInsertSort(SqList &L)
{//对顺序表L进行折半插入排序
for(i=2;i<=L.length;++i)
{
L.r[0]=L.r[i];//将待插入的记录暂存到监视哨中
low=1;high=i-1;//置查找区间初值
while(low<=high) //在r[low..high]中折半查找插入的位置
{
m=(low+high)/2; //折半
if(L.r[0].key<L.r[m].key) high=m-1; //插入点在前一子表
else low=m+1; //插入点在后一子表
} //while
for(j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]; //记录后移
L.r[high+1]=L.r[0]; //将r[0]即原r[i],插入正确位置
} //for
}
折半插入查找在原来的插入查找的基础上进行了折半查找的过程,而不是原来的顺序查找
折半插入查找的时间复杂度依然为O(n^2),虽然使用折半查找减少了比较的次数,但是依然是要每次移动,每次移动的过程中又要依次后移,所以时间复杂度是不变的
空间复杂度依然为O(1),没有新开辟空间
【算法特点】
(1)稳定排序。
(2)因为要进行折半查找,所以只能用于顺序结构,不能用于链式结构。
(3)适合初始记录无序、n较大的情况。
希尔排序
希尔对记录的分组,不是简单地“逐段分割”,而是将相隔某个“增量”的记录分成 一组。
① 第一趟取增量d1(d1<…< d2 < d1),所有记录在同一组中进行直接 插入排序为止。
② 第二趟取增量d2(d2<d1),重复上述的分组和排序。
③ 依次类推,直到所取的增量dt = 1(dt <…< d2 < d1),所有记录在同一组中进行直接 插入排序为止。
希尔排序的平均时间复杂度为O(nlog2n)最坏的时间复杂度为O(n^2)
空间复杂度为O(1)
是一个不稳定的排序
交换排序
冒泡排序
void BubbleSort(SqList &L)
{//对顺序表L进行冒泡排序
m=L.length-1;flag=1; //flag用来标记某一趟排序是否发生交换
while((m>0)&&(flag==1))
{
flag=0;//flag置为0,如果本趟排序没有发生交换,则不会执行下一趟排序
for(j=1;j<=m;j++)
if(L.r[j].key>L.r[j+1].key)
{
flag=1; //flag置为1,表示本趟排序发生了交换
t=L.r[j]; L.r[j]=L.r[j+1]; L.r[j+1]=t;//交换前后两个记录
} //if
--m;
} //while
} //BubbleSort
时间复杂度O(n^2)
空间复杂度O(1)
该算法是稳定的
快速排序
int Partition(SqList &L, int low, int high)
{//对顺序表L中的子表r[low..high]进行一趟排序,返回枢轴位置
L.r[0]=L.r[low];//用子表的第一个记录作为枢轴记录
pivotkey=L.r[low].key; //枢轴记录关键字保存在pivotkey中
while(low<high) //从表的两端交替地向中间查找
{
while(low<high&&L.r[high].key>=pivotkey) --high;
L.r[low]=L.r[high]; //将比枢轴记录小的记录移到低端
while(low<high&&L.r[low].key<=pivotkey) ++low;
L.r[high]=L.r[low]; //将比枢轴记录大的记录移到高端
} //while
L.r[low]=L.r[0]; //枢轴记录到位
return low; //返回枢轴位置
}
void QSort(SqList &L,int low,int high)
{//调用前置初值 :low=1; high=L.length;
//对顺序表L中的子表L.r[low..high]进行快速排序
if(low<high){ //长度大于1
pivotloc=Partition(L, low, high); //将L.r[low..high]一分为二,pivotloc是枢轴位置
QSort(L, low, pivotloc-1); //对左子表递归排序
QSort(L, pivotloc+1, high);//对右子表递归排序
}
}
void QuickSort(SqList &L)
{//对顺序表L进行快速排序
QSort(L,1,L.length);
}
快速排序最好的时间复杂度为O(nlog2n)最坏的时间复杂度为O(n^2)平均的时间复杂度为O(nlog2n)
空间复杂度:快速排序是递归的,执行时需要有一个栈来存放相应的数据。最大递归调用次数与递归树 的深度一致,所以最好情况下的空间复杂度为O(log2n),最坏情况下为O(n)。
【算法特点】
(1)记录非顺次的移动导致排序方法是不稳定的。
(2)排序过程中需要定位表的下界和上界,所以适合用于顺序结构,很难用于链式结构。
(3)当n较大时,在平均情况下快速排序是所有内部排序方法中速度最快的一种,所以其 适合初始记录无序、n较大的情况。
选择排序
简单选择排序
void SelectSort(SqList &L)
{//对顺序表L进行简单选择排序
for(i=1;i<L.length;++i){ //在L.r[i..L.length] 中选择关键字最小的记录
k=i;
for(j=i+1;j<=L.length;++j)
if(L.r[j].key<L.r[k].key) k=j; //k指向此趟排序中关键字最小的记录
if(k!=i)
{t=L.r[i]; L.r[i]=L.r[k]; L.r[k]=t;} //交换r[i]与r[k]
} //for
}
每次选择最小的那个放在已经排好序列的最右边
时间复杂度O(n^2)
空间复杂度O(1)
堆排序
堆排序(Heap Sort)是一种树形选择排序,在排序过程中,将待排序的记录r[1..n]看成一棵 完全二叉树的顺序存储结构,利用完全二叉树中双亲节点和孩子节点之间的内在关系,在当前 无序的序列中选择关键字最大(或最小)的记录 (按完全二叉树进行排序)
每次取完全二叉树中的最后一个的孩子节点放到树根,跟树根交换位置,然后再进行重新的排序即可,只要理解堆排序的选择即可
然后堆排序的时间复杂度为O(nlog2n)
堆排序也是不稳定的排序
归并排序
归并排序(Merging Sort)就是将两个或两个以上的有序表合并成一个有序表的过程。将两 个有序表合并成一个有序表的过程称为2-路归并,2-路归并最为简单和常用。下面以2-路归并为 例,介绍归并排序算法。 归并排序算法的思想是:假设初始序列含有n个记录,则可将其看成n个有序的子序列,每 个子序列的长度为1,然后两两归并,得到n/2(向上取整)个长度为2或1的有序子序列;再两两归并,如此 重复,直至得到一个长度为n的有序序列为止。