本文详细介绍了排序算法的基本概念和几种常见的排序算法，包括直接插入排序、希尔排序、冒泡排序、快速排序、选择排序以及堆排序和归并排序。对于每种排序算法，文章阐述了其基本思想、算法实现、性能分析和适用场景，旨在帮助读者理解和掌握排序算法的原理和应用。
排序
文章目录
基本概念
-
排序：给定一组记录的集合
{r1, r2, ……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1, rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。 -
正序：待排序序列中的记录已按关键码排好序。
-
逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。
-
排序算法的稳定性：假定在待排序的记录集中，存在多个具有相同键值的记录，若经过排序，这些记录的相对次序仍然保持不变，即在原序列中，ki=kj且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。
-
单键排序：根据一个关键码进行的排序；
-
多键排序：根据多个关键码进行的排序。`
-
设关键码分别为k1, k2, …, km，多键排序有两种方法：
-
依次对记录进行m次排序，第一次按k1排序，第二次按k2排序，依此类推。这种方法要求各趟排序所用的算法是稳定的；
-
将关键码k1, k2, …, km分别视为字符串依次首尾连接在一起，形成一个新的字符串，然后，对记录序列按新形成的字符串排序。
思路均是将多键排序转化成单键排序
-
-
排序的分类
- 内外排序
- 内排序：在排序的整个过程中，待排序的所有记录全部被放置在内存中.(内部排序的过程是一个逐步扩大记录的有序序列长度的过程),大致分为 插入类,交换类,选择类,归并类等.
- 外排序：由于待排序的记录个数太多，不能同时放置在内存，而需要将一部分记录放置在内存，另一部分记录放置在外存上，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果。
- 是否比较
- 基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为Ω（nlog2n）。
- 不基于比较：根据关键码的分布特征。
- 内外排序
-
性能
-
基本操作
- 比较: 关键码之间的比较；
- 移动: 记录从一个位置移动到另一个位置.
-
辅助存储空间
辅助存储空间是指在数据规模一定的条件下，除了存放待排序记录占用的存储空间之外，执行算法所需要的其他存储空间。
-
算法本身复杂度
-
-
存储结构
排序是线性结构的一种操作，待排序记录可以用顺序存储结构或链接存储结构存储。
插入排序
基本思想
每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止。
#define MAXSIZE 1000 // 待排顺序表最大长度
typedef int KeyType; // 关键字类型为整数类型
typedef struct { // 待排序元素
KeyType key; // 关键字项
InfoType otherinfo; // 其它数据项
} RcdType;
typedef struct { // 待排序数组
RcdType r[MAXSIZE+1]; // r[0]闲置
int length; // 顺序表长度
} SqList;
实现“一趟插入排序”可分三步进行：
-
在
R[1..i-1]中查找R[i]的插入位置，R[1..j].key < R[i].key < R[j+1..i-1].key -
将
R[j+1..i-1]中的所有记录均后移一个位置. -
将
R[i]插入(复制)到R[j+1]的位置上。
直接插入排序
基本思想
在插入第 i（i＞1）个记录时，前面的i-1个记录已经排好序。
算法
void insertSort (int r[ ], int n){ // 直接插入排序
for (i=2; i<=n; i++){
r[0]=r[i]; // r[0]用来记录即将插入的元素
for (j=i-1;r[0]<r[j];j--)
r[j+1]=r[j]; // 向后移动
r[j+1]=r[0]; // 插入(复制)
}
}
复杂度分析
最好情况
完全正序,比较次数 n-1,移动次数2*(n-1)
复杂度O(n)
最坏情况
O(n^2)
平均情况下是O(n^2)
- 直接插入排序算法是一种稳定的排序算法。
- 直接插入排序算法简单、容易实现，适用于待排序记录基本有序或待排序记录较小时。
- 当待排序的记录个数较多时，大量的比较和移动操作使直接插入排序算法的效率降低。
表插入排序
#### 概念
利用静态链表进行排序，并在排序完成之后，一次性地调整各个记录相互之间的位置
#define SIZE 100
typedef struct {
RcdType rc; // 记录项
int next; // 指针项
} SLNode; // 表结点类型
typedef struct {
SLNode r[SIZE]; // 0号单元是表头结点
int length; // 链表当前长度
} SLinkListType; // 静态链表类型
基本思想
数组0号单元设为表头结点，通过循环链表，依次将下标为```2~n```的结点按关键字非递减有序插入到循环链表中。
与直接插入排序相比只是避免了移动记录的过程（修改各记录结点中的指针域即可），而插入过程中同其它关键字的比较次数并没有改变，所以表插入排序算法的时间复杂度仍是O(n^2)。
有序表的折半查找
重排记录算法：顺序扫描有序链表将链表中的第i个结点移到数组的第i个分量，算法使用了三个指针：
- p 指示第
i个记录的当前位置
其中：p指示第i个记录的当前位置
-
i 指示第
i个记录应在的位置 -
q 指示第
i+1个记录的当前位置
void Arrange ( Elem SL[ ], int n ) {
p = SL[0].next; // p指示第一个记录的当前位置
for ( i=1; i<n; ++i ) {
while (p<i) p = SL[p].next;
q = SL[p].next; // q指示尚未调整的表尾
if ( p!= i ) {
SL[p]←→SL[i]; // 交换记录，使第i个记录到位
SL[i].next = p; // 指向被移走的记录
}
p = q; // p指示尚未调整的表尾，
// 为找第i+1个记录作准备
}
} // Arrange
希尔排序
改进的着眼点：
- 若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；
- 由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。
基本思想
将整个待排序记录分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列中的记录基本有序时，对全体记录进行直接插入排序。
局部有序不能提高直接插入排序算法的时间性能，但基本有序可以。所以子序列的构成不能是简单地“逐段分割”，而是将相距某个“增量”的记录组成一个子序列
算法
void ShellInsert(SqList &L,int dk){ // 对顺序表L作一趟希尔插入排序,dk表示增量
for(int i=dk+1;i<=L.length;i++){ //
if(LT(L.r[i].key,L.r[i-dk].key)){
L.r[0]=L.r[i];
for(int j=i-dk;j>0&<(L.r[0].key,L.r[j].key);j-=dk)
L.r[j+dk]=L.r[j];
L.r[j+dk]=L.r[0];
}
}
}
void ShellSort(SqList &L,in dlta[],int t){ // 希尔排序
// 这里是假设存在了增量序列dlta[0……t-1]对顺序表L作希尔排序
for(int k=0;k<t;k++){
ShellInsert(L,dlta[k]); // 一趟增量dlta[k]的插入排序
}
}
书上指出应当使增量序列中的值没有除1之外的公因子，并且最后一个增量值必须为1，但是ppt上却直接无视了这一条，实在是令人摸不到头脑。
时间性能
希尔排序的时间性能在O(n2)和O(nlog2n)之间。当n在某个特定范围内，希尔排序所需的比较次数和记录的移动次数约为O(n^1.3)
交换排序
基本思想
交换排序的主要操作是交换，其主要思想是：在待排序列中选两个记录，将它们的关键码相比较，如果反序（即排列顺序与排序后的次序正好相反），则交换它们的存储位置。
冒泡排序
void BubbleSort(int r[ ], int n){
int exchange=n;
while (exchange) {
int bound=exchange; // bound是比较的终点
exchange=0;
for (j=1; j<bound; j++){
if (r[j]>r[j+1]) {
r[j]←→r[j+1]；
exchange=j；
}
}
}
}
最好情况的时间复杂度是O(n)
最坏情况的时间复杂度是O(n^2)
平均情况的时间复杂度是O(n^2)
可以魔改成双向气泡排序,即在排序过程中交题改变扫描方向.
快速排序
基本思想
在起泡排序中，记录的比较和移动是在相邻单元中进行的，记录每次交换只能上移或下移一个单元，因而总的比较次数和移动次数较多。
故增大记录的比较和移动距离,较大记录从前面直接移动到后面,较小记录从后面直接移动到前面,就可以减少次数.
#### 算法
首先选一个轴值（即比较的基准），通过一趟排序将待排序记录分割成独立的两部分，前一部分记录的关键码均小于或等于轴值，后一部分记录的关键码均大于或等于轴值，然后分别对这两部分重复上述方法，直到整个序列有序．
#define MAX 8
typedef struct {
int key;
}SqNote;
typedef struct {
SqNote r[MAX];
int length;
}SqList;
//交换两个记录的位置
void swap(SqNote *a,SqNote *b){
int key=a->key;
a->key=b->key;
b->key=key;
}
int Partition(SqList *L,int low,int high){ //快速排序，分割的过程
int pivotkey=L->r[low].key;
//直到两指针相遇，程序结束
while (low<high) {
//high指针左移，直至遇到比pivotkey值小的记录，指针停止移动
while (low<high && L->r[high].key>=pivotkey) {
high--;
}
//交换两指针指向的记录
swap(&(L->r[low]), &(L->r[high]));
//low 指针右移，直至遇到比pivotkey值大的记录，指针停止移动
while (low<high && L->r[low].key<=pivotkey) {
low++;
}
//交换两指针指向的记录
swap(&(L->r[low]), &(L->r[high]));
}
return low;
}
void QuickSort (int r[ ], int first, int end ){ // 快速排序
if(first < end){
pivotpos = Partition (r, first, end ); //一次划分
QuickSort (r, first, pivotpos-1);
//对前一个子序列进行快速排序
QuickSort (r, pivotpos+1, end );
//对后一个子序列进行快速排序
}
}
时间性能分析
最好情况:每一次划分对一个记录定位后，该记录的左侧子表与右侧子表的长度相同，为O(n*log n)。
最坏情况:每次划分只得到一个比上一次划分少一个记录的子序列（另一个子序列为空），为O(n＾2)。
平均情况?(n*log n)
选择排序
基本思路
选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
第 i 趟在n-i+1（i=1,2,…,n-1）个记录中选取关键码最小的记录作为有序序列中的第 i 个记录。
算法
void selectSort ( int r[ ], int n){ // 选择排序
for ( i=1; i<n; i++) { // 不断扩展
index=i;
for (j=i+1; j<=n; j++){ // 找到距离i最小的值
if (r[j]<r[index]) {
index=j;
}
}
if (index!=i) // 如果找到了就交换
r[i]<==>r[index];
}
}
性能分析
时间复杂度:O(n^2)
是一种稳定的排序方法
堆排序
堆的定义
堆是具有下列性质的完全二叉树：每个结点的值都小于或等于其左右孩子结点的值（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）
将堆用顺序存储结构来存储，则堆对应一组序列。
基本思想
首先将待排序的记录序列构造成一个堆，此时，选出了堆中所有记录的最大者，然后将它从堆中移走，并将剩余的记录再调整成堆，这样又找出了次大的记录，以此类推，直到堆中只有一个记录。
堆调整
#define MAX 9
//单个记录的结构体
typedef struct {
int key;
}SqNote;
//记录表的结构体
typedef struct {
SqNote r[MAX];
int length;
}SqList;
void HeapAdjust(SqList * H,int s,int m){ //将以 r[s]为根结点的子树构成堆，堆中每个根结点的值都比其孩子结点的值大
SqNote rc=H->r[s]; // 先对操作位置上的结点数据进行保存，放置后序移动元素丢失。
// 对于第 s 个结点，筛选一直到叶子结点结束
for (int j=2*s; j<=m; j*=2) {
// 在左右儿子中 找到值最大的孩子结点
if (j+1 < m && (H->r[j].key < H->r[j+1].key)) {
j++;
}
// 如果当前结点比最大的孩子结点的值还大，则不需要对此结点进行筛选，直接略过
if (!(rc.key<H->r[j].key)) {
break;
}
// 如果当前结点的值比孩子结点中最大的值小，则将最大的值移至该结点，由于 rc 记录着该结点的值，所以该结点的值不会丢失
H->r[s]=H->r[j];
s=j; // s相当于指针的作用，指向其孩子结点，继续进行筛选
}
H->r[s]=rc; // 最终需将rc的值添加到正确的位置
}
//交换两个记录的位置
void swap(SqNote *a,SqNote *b){
int key=a->key;
a->key=b->key;
b->key=key;
}
void HeapSort(SqList *H){
//构建堆的过程
for (int i=H->length/2; i>0; i--) {
//对于有孩子结点的根结点进行筛选
HeapAdjust(H, i, H->length);
}
//通过不断地筛选出最大值，同时不断地进行筛选剩余元素
for (int i=H->length; i>1; i--) {
//交换过程，即为将选出的最大值进行保存大表的最后，同时用最后位置上的元素进行替换，为下一次筛选做准备
swap(&(H->r[1]), &(H->r[i]));
//进行筛选次最大值的工作
HeapAdjust(H, 1, i-1);
}
}
int main() {
SqList * L=(SqList*)malloc(sizeof(SqList));
L->length=8;
L->r[1].key=49;
L->r[2].key=38;
L->r[3].key=65;
L->r[4].key=97;
L->r[5].key=76;
L->r[6].key=13;
L->r[7].key=27;
L->r[8].key=49;
HeapSort(L);
for (int i=1; i<=L->length; i++) {
printf("%d ",L->r[i].key);
}
return 0;
}
归并排序
基本思想
将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，然后进行两两归并，得到n/2个长度为2的有序序列，再进行两两归并，得到n/4个长度为4的有序序列，……，直至得到一个长度为n的有序序列为止。
算法
#define MAX 8
typedef struct{
int key;
}SqNode;
typedef struct{
SqNode r[MAX];
int length;
}SqList;
//SR中的记录分成两部分：下标从 i 至 m 有序，从 m+1 至 n 也有序，此函数的功能是合二为一至TR数组中，使整个记录表有序
void Merge(SqNode SR[],SqNode TR[],int i,int m,int n){
int j,k;
//将SR数组中的两部分记录按照从小到大的顺序添加至TR数组中
for (j=m+1,k=i; i<=m && j<=n; k++) {
if (SR[i].key<SR[j].key) {
TR[k]=SR[i++];
}else{
TR[k]=SR[j++];
}
}
//将剩余的比目前TR数组中都大的记录复制到TR数组的最后位置
while(i<=m) {
TR[k++]=SR[i++];
}
while (j<=n) {
TR[k++]=SR[j++];
}
}
void MSort(SqNode SR[],SqNode TR1[],int s,int t){
SqNode TR2[MAX];
//递归的出口
if (s==t) {
TR1[s]=SR[s];
}else{
int m=(s+t)/2;//每次递归将记录表中记录平分，直至每个记录各成一张表
MSort(SR, TR2, s, m);//将分开的前半部分表中的记录进行排序
MSort(SR,TR2, m+1, t);//将后半部分表中的记录进行归并排序
Merge(TR2,TR1,s,m, t);//最后将前半部分和后半部分中的记录统一进行排序
}
}
//归并排序
void MergeSort(SqList *L){
MSort(L->r,L->r,1,L->length);
}
int main() {
SqList * L=(SqList*)malloc(sizeof(SqList));
L->length=7;
L->r[1].key=49;
L->r[2].key=38;
L->r[3].key=65;
L->r[4].key=97;
L->r[5].key=76;
L->r[6].key=13;
L->r[7].key=27;
MergeSort(L);
for (int i=1; i<=L->length; i++) {
printf("%d ",L->r[i].key);
}
return 0;
}
扫一扫
1884
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
