第二十三次-排序(一)

排序的基本概念

排序：给定一组记录的集合{r1, r2,
……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1,
rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。

正序：待排序序列中的记录已按关键码排好序。

逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。

趟：在排序过程中，将待排序的记录序列扫描一遍称为一趟。

通常，一次排序过程需要进行多趟扫描才能完成
1
排序算法的稳定性：

假定在待排序的记录集中，存在多个具有相同键值的记录，

若经过排序，这些记录的相对次序仍然保持不变，

即在原序列中，ki=kj且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

排序算法的稳定性

对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；

而对于稳定的排序算法，必须对算法进行分析从而证明稳定的特性。

需要注意的是，排序算法是否为稳定的是由具体算法决定的。

不稳定的算法在某种条件下可以变为稳定的算法，

而稳定的算法在某种条件下也可以变为不稳定的算法。

算法的稳定性与算法的具体实现有关

冒泡排序是稳定的排序方法

5，3，3，4

如果规则是 A[i]>a[i+1]，则是稳定

如果规则是A[i]>=a[i+1]，则是不稳定的排序方法

快速排序原本是不稳定的排序方法，

但若待排序记录中只有一组具有相同关键码的记录，而选择的轴值恰好是这组相同关键码中的一个，此时的快速排序就是稳定的。

排序的基本概念

排序的分类-根据排序数据在内存中还是在外存中：

内排序：在排序的整个过程中，待排序的所有记录全部被放置在内存中

外排序：由于待排序的记录个数太多，不能同时放置在内存，而需要将一部分记录放置在内存，另一部分记录放置在外存上，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果。
排序的分类-根据排序过程中所进行的基本操作分：

基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为O（nlog2n）。

不基于比较：根据关键码的分布特征。比如，桶式排序，基数排序（多关键字排序）

基于比较的内排序

插入排序

交换排序

选择排序

归并排序

不基于比较的内排序

分配排序

桶式排序

基数排序
1
2
3
排序算法的性能

时间复杂性：基本操作。

内排序在排序过程中的基本操作：

⑴比较：关键码之间的比较；

⑵移动：记录从一个位置移动到另一个位置。

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

}
}

希尔排序

改进的依据：

（1）若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；

（2）由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。

基本有序：

例如{1, 2, 8, 4, 5, 6, 7, 3, 9}；

接近正序，

局部有序：

例如{6, 7, 8, 9, 1, 2, 3, 4, 5}。

部分有序，

局部有序不能提高直接插入排序算法的时间性能。

基本思想：

将整个待排序记录分割成若干个子序列，

在子序列内分别进行直接插入排序，

待整个序列中的记录基本有序时，对全体记录进行直接插入排序。

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

   }
}

}

起泡排序算法

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

 
  }

}

}

快速排序的基本思想

首先选一个轴值（即比较的基准），

通过一趟排序将待排序记录分割成独立的两部分，

前一部分记录的关键码均小于或等于轴值，

后一部分记录的关键码均大于或等于轴值，

然后分别对这两部分重复上述方法，直到整个序列有序。

快速排序的基本思想

void QuickSort (int r[ ], int first, int end )

{//在序列 first~end中递归地进行快速排序

if (first < end) {

pivotpos = Partition (r, first, end );

QuickSort (r, first, pivotpos-1);

QuickSort (r, pivotpos+1, end );

}

}