排序

排序的基本概念
排序：给定一组记录的集合{r1, r2, ……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1, rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。
正序：待排序序列中的记录已按关键码排好序。
逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。
趟：在排序过程中，将待排序的记录序列扫描一遍称为一趟。
通常，一次排序过程需要进行多趟扫描才能完成

排序算法的稳定性：
假定在待排序的记录集中，存在多个具有相同键值的记录，
若经过排序，这些记录的相对次序仍然保持不变，
即在原序列中，ki=kj且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；
而对于稳定的排序算法，必须对算法进行分析从而证明稳定的特性。
需要注意的是，排序算法是否为稳定的是由具体算法决定的。
不稳定的算法在某种条件下可以变为稳定的算法，
而稳定的算法在某种条件下也可以变为不稳定的算法。

排序的分类-根据排序数据在内存中还是在外存中：
1.内排序：在排序的整个过程中，待排序的所有记录全部被放置在内存中
2.外排序：由于待排序的记录个数太多，不能同时放置在内存，而需要将一部分记录放置在内存，另一部分记录放置在外存上，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果。

排序的分类-根据排序过程中所进行的基本操作分：

1. 基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为O（nlog2n）。
2. 不基于比较：根据关键码的分布特征。比如，桶式排序，基数排序（多关键字排序）

基于比较的内排序

1. 插入排序
2. 交换排序
3. 选择排序
4. 归并排序

不基于比较的内排序

1. 分配排序
   桶式排序
   基数排序

排序算法的性能：
1.时间复杂性：基本操作。
内排序在排序过程中的基本操作：
⑴比较：关键码之间的比较；
⑵移动：记录从一个位置移动到另一个位置。
2.空间复杂性： 辅助存储空间。
辅助存储空间是指在数据规模一定的条件下，除了存放待排序记录占用的存储空间之外，执行算法所需要的其他存储空间。

插入排序
1.插入排序的主要操作是插入，
其基本思想是：
每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止。
插入类排序方法有以下两种：
直接插入排序
希尔排序
2.直接插入排序
void insertSort (int r[ ], int n){
for (i=2; i<=n; i++) {
r[0]=r[i]; j=i-1;
while (r[0]<r[j]) {
r[j+1]=r[j];
j=j-1;
}
r[j+1]=r[0];
}
}
3.希尔排序
基本思想：
将整个待排序记录分割成若干个子序列，
在子序列内分别进行直接插入排序，
待整个序列中的记录基本有序时，对全体记录进行直接插入排序。
void Shellsort(int r[],int n){
for (d=n/2; d>=1; d=d/2){
for (i=d+1; i<=n; i++) {
r[0]=r[i];
j=i-d;
while (j>0 && r[0]<r[j])
{
r[j+d]=r[j];
j=j-d;
}
r[j+d]=r[0];
}
}
}

交换排序

1. 交换排序的主要操作是交换，其主要思想是：在待排序列中选两个记录，将它们的关键码相比较，如果反序（即排列顺序与排序后的次序正好相反），则交换它们的存储位置。
   交换类排序的两种方法
   冒泡排序
   快速排序

2. 起泡排序
   基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。
   void BubbleSort(int r[ ], int n)
   {
   exchange=n;
   while (exchange)
   {
   bound=exchange;
   exchange=0；
   for (j=1; j<bound; j++)
   if (r[j]>r[j+1]) {
   r[j]←→r[j+1]；
   exchange=j；
   }
   }
   }
   void BubbleSort(int r[ ], int n)
   {
   change=true; bound=n;
   while (change)
   {
   change=false;

    for (j=1; j<bound; j++)
        if (r[j]>r[j+1]) {
            r[j]←→r[j+1]；
      bound=j；
      change=true
        }
   

   }
   }
   3.快速排序
   首先选一个轴值（即比较的基准），
   通过一趟排序将待排序记录分割成独立的两部分，
   前一部分记录的关键码均小于或等于轴值，
   后一部分记录的关键码均大于或等于轴值，
   然后分别对这两部分重复上述方法，直到整个序列有序。

四、选择排序

选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
简单选择排序
堆排序
3.简单选择排序
基本思想：第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++)
if (r[j]<r[index]) index=j;
if (index!=i) r[i]<==>r[index];
}
}
4.堆排序
（1）堆是具有下列性质的完全二叉树：每个结点的值都小于或等于其左右孩子结点的值（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）。
（2）首先将待排序的记录序列构造成一个堆(大顶堆)，
此时，选出了堆中所有记录的最大者，然后将它从堆中移走，
并将剩余的记录再调整成堆，
这样又找出了次大的记录，以此类推，直到堆中只有一个记录。
（3）堆调整
void sift ( int r[ ], int k, int m )
{//要筛选结点的编号为k，堆中最后一个结点的编号为m
i=k; j=2i; temp=r[i]; //将筛选记录暂存
while (j<=m ) //筛选还没有进行到叶子
{
if (j<m && r[j]<r[j+1]) j++; //左右孩子中取较大者
if (temp>r[j]) break;
else {
r[i]=r[j]; i=j; j=2i;
}
}
r[i]=temp; //将筛选记录移到正确位置
}
（4）堆排序算法
①创建堆
② 重复进行以下工作
输出堆顶 r[1]
调整工作(1…n-i, i表示调整次数)
void HeapSort ( int r[], int n)
{
for (i=n/2; i>=1; i–) //初建堆
sift(r, i, n) ;
for (i=1; i<n; i++ )
{
r[1]←→r[n-i+1]; //移走堆顶
sift(r, 1, n-i); //重建堆
}
}

归并排序
1.归并：将两个或两个以上的有序序列合并成一个有序序列的过程。
归并排序的主要操作是归并，其主要思想是：将若干有序序列逐步归并，最终得到一个有序序列。
2.二路归并排序
基本思想：
将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，
然后进行两两归并，
得到n/2个长度为2的有序序列，
再进行两两归并，得到n/4个长度为4的有序序列，
……，
直至得到一个长度为n的有序序列为止。
void Merge (int r[ ], int r1[ ], int s, int m, int t )
{
i=s; j=m+1; k=s;
while (i<=m && j<=t)
{
if (r[i]<=r[j]) r1[k++]=r[i++];
else r1[k++]=r[j++];
}
if (i<=m) while (i<=m) //收尾处理
r1[k++]=r[i++]; //前一个子序列
else while (j<=t)
r1[k++]=r[j++]; //后一个子序列
}

分配排序
1.基于分配和收集
基本思想
先将数据分配到不同的桶中
再将桶中的数据收集到一起
两种方法
桶式排序(单关键字排序)
链式基数排序（多关键字排序）
特点
排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序
它们的时间复杂度可达到线性阶：O(n)。
2.桶式排序
假设待排序的记录的值在0~m-1之间
设置m个桶，
依次扫描待排序的记录，R[1]，…，R[n-1]，把关键字等于k的记录全都装入到 第k个箱子里(分配)，
然后按序号依次将各非空的箱子首尾连接起来(收集)。
void collect( head *list, Node *&first,int m){ //收集算法
int i=0,j;
while(list[i].firstNULL) i++;
if(i>m) return;
first=list[i].first;
while(i<=m) {
j=i+1;
while(list[j].firstNULL) j++;
if(j>m) return;
list[i].rear->next=list[j].first;
i=j;
}
}

int main(){ //桶式排序算法
Node *s,*first; head *list;
int m;cin>>m;
list=new head[m];
for (int i=0;i<=m;i++) {
list[i].first=NULL; list[i].rear=NULL;}
int n;
cin>>n;
first=NULL;
for( i=0;i<n;i++)
{ s=new Node; cin>>s->data; s->next=first; first=s; }
distribute(first,n,list);
collect(list,first,m);
Node *p=first;
while§{
cout<data<<"\t"; p=p->next; }
cout<<endl;
return 0;
}
3.基数排序
基数排序是典型的LSD排序方法，利用“分配”和“收集”两种运算对单关键码进行排序。
基本思想
从关键字的最“低位”开始，将关键字分配到r(基数）个堆（桶）中；
按桶的编号将关键字收集起来；
然后，以“次低位”将关键字又分配到r个桶中；再收集，……，重复直到“最高位”为止，这时，以按关键字有序。