第8章排序

傷城~ 2022-08-25 02:27 206阅读 0赞

**第8章 排序（sort）或分类**  
  
 　所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：  
　　输入：n个记录R1，R2，…，Rn，其相应的关键字分别为K1，K2，…，Kn。  
　　输出：Ril，Ri2，…，Rin，使得Ki1≤Ki2≤…≤Kin。(或Ki1≥Ki2≥…≥Kin)。  
  
**1．被排序对象--文件**  
　　被排序的对象--文件由一组记录组成。  
　　记录则由若干个数据项(或域)组成。其中有一项可用来标识一个记录，称为关键字项。该数据项的值称为关键字(Key)。  
注意：  
　 在不易产生混淆时，将关键字项简称为关键字。  
  
**2．排序运算的依据--关键字**  
　用来作排序运算依据的关键字，可以是数字类型，也可以是字符类型。  
　 关键字的选取应根据问题的要求而定。  
【例】在高考成绩统计中将每个考生作为一个记录。每条记录包含准考证号、姓名、各科的分数和总分数等项内容。若要惟一地标识一个考生的记录，则必须用"准考证号"作为关键字。若要按照考生的总分数排名次，则需用"总分数"作为关键字。  
  
**3．排序的稳定性**  
  
　 当待排序记录的关键字均不相同时，排序结果是惟一的，否则排序结果不唯一。  
　在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是**稳定的**；若具有相同关键字的记录之间的相对次序发生变化，则称这种排序方法是**不稳定的**。  
注意：  
　 排序算法的稳定性是针对所有输入实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。  
  
**4．排序方法的分类**  
  
**按策略划分内部排序方法**  
　可以分为五类：插入排序、选择排序、交换排序、归并排序和分配排序。

**5．交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。  
　应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。**  
  
**冒泡排序  
  
1、排序方法**  
　将被排序的记录数组R\[1..n\]垂直排列，每个记录R\[i\]看作是重量为R\[i\].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。  
（1）初始  
　 R\[1..n\]为无序区。  
  
（2）第一趟扫描  
　 从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R\[n\]，R\[n-1\])，(R\[n-1\]，R\[n-2\])，…，(R\[2\]，R\[1\])；对于每对气泡(R\[j+1\]，R\[j\])，若R\[j+1\].key<R\[j\].key，则交换R\[j+1\]和R\[j\]的内容。  
　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R\[1\]上。  
  
（3）第二趟扫描  
　 扫描R\[2..n\]。扫描完毕时，"次轻"的气泡飘浮到R\[2\]的位置上……  
　最后，经过n-1 趟扫描可得到有序区R\[1..n\]  
 注意：  
　 第i趟扫描时，R\[1..i-1\]和R\[i..n\]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R\[i\]上，结果是R\[1..i\]变为新的有序区。  
  
**2、冒泡排序过程示例**  
　对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程【[参见动画演示][Link 1]】  
  
**3、排序算法**  
（1）分析  
　因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。  
　若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。  
  
（2）具体算法  
void BubbleSort(SeqList R)  
\{ //R（l..n)是待排序的文件，采用自下向上扫描，对R做冒泡排序  
int i，j；  
Boolean exchange； //交换标志  
for(i=1;i<n;i++)\{ //最多做n-1趟排序  
exchange=FALSE； //本趟排序开始前，交换标志应为假  
for(j=n-1;j>=i；j--) //对当前无序区R\[i..n\]自下向上扫描  
if(R\[j+1\].key<R\[j\].key)\{//交换记录  
R\[0\]=R\[j+1\]； //R\[0\]不是哨兵，仅做暂存单元  
R\[j+1\]=R\[j\]；  
R\[j\]=R\[0\]；  
exchange=TRUE； //发生了交换，故将交换标志置为真  
\}  
if(!exchange) //本趟排序未发生交换，提前终止算法  
return；  
\} //endfor(外循环)  
\} //BubbleSort

冒泡排序(Bubble Sort)是基本的交换排序。

先来看看待排序列一趟冒泡的过程：设1<j≤n，r\[1\],r\[2\],···,r\[j\]为待排序列，通过两两比较、交换，重新安排存放顺序，使得r\[j\]是序列中关键码最大的记录。一趟冒泡方法为：

① i=1；//设置从第一个记录开始进行两两比较

② 若i≥j，一趟冒泡结束。

③ 比较r\[i\].key与r\[i+1\].key，若r\[i\].key≤r\[i+1\].key，不交换，转⑤

④ 当r\[i\].key>r\[i+1\].key时， r\[0\]=r\[i\]；r\[i\]=r\[i+1\]；r\[i+1\]=r\[0\]；

将r\[i\]与r\[i+1\]交换

⑤ i=i+1； 调整对下两个记录进行两两比较，转②

冒泡排序方法：对n个记录的表，第一趟冒泡得到一个关键码最大的记录r\[n\]，第二趟冒泡对n-1个记录的表，再得到一个关键码最大的记录r\[n-1\]，如此重复，直到n个记录按关键码有序的表。

**算法8.3**

① j=n；//从n记录的表开始

② 若j<2，排序结束

③ i=1；//一趟冒泡，设置从第一个记录开始进行两两比较，

④ 若i≥j，一趟冒泡结束，j=j-1；冒泡表的记录数\-1，转②

⑤ 比较r\[i\].key与r\[i+1\].key，若r\[i\].key≤r\[i+1\].key，不交换，转⑤

⑥ 当r\[i\].key>r\[i+1\].key时， r\[i\]<-->r\[i+1\]； 将r\[i\]与r\[i+1\]交换

⑦ i=i+1； 调整对下两个记录进行两两比较，转④

**效率分析**

空间效率：仅用了一个辅助单元。

时间效率：总共要进行n-1趟冒泡，对j个记录的表进行一趟冒泡需要j-1次关键码比较。

移动次数：![blob_key_2150266_filename_4.jpg][]

最好情况下：待排序列已有序，不需移动。

\#include <stdio.h>

void bubble(int a\[\],int n);

void swap(int \*x,int \*y);

main()

int i,n,a\[30\];

scanf("%d",&n);

for(i=0;i<n;i++)

scanf("%d",&a\[i\]);

bubble(a,n);

for(i=0;i<n;i++)

printf("%d ",a\[i\]);

printf("/n");

void bubble(int \*a,int n)

int i,j;

for(i=0;i<n;i++)

for(j=n-1;j>i;j--)

if(a\[j-1\]>a\[j\])

swap(&a\[j-1\],&a\[j\]);

void swap(int \*x,int \*y)

int t;

t=\*x;\*x=\*y;\*y=t;

**改进的****冒泡程序：**

void bubble(int \*a,int n)

int t,i,j,flag=1;

for(i=0;i<n&&flag;i++)

flag=0;

for(j=n-1;j>i;j--)

if(a\[j-1\]>a\[j\])

\{t=a\[j-1\];a\[j-1\]=a\[j\];a\[j\]=t;flag=1;\}

///一个完整程序例子/

\#include <stdio.h>  
\#include <stdlib.h>  
\#include <string.h>  
\#define MAXITEM 100  
typedef int KeyType;  
typedef char ElemType\[5\];  
typedef struct rec  
\{  
KeyType key; /\*关键字域\*/  
ElemType data; /\*数据域\*/  
\} elemnode\[MAXITEM\];  
void bubblesort(elemnode r,int n)  
\{  
int i,j;  
for (i=1;i<=n-1;i++)  
for (j=n;j>=i+1;j--)  
if (r\[j\].key<r\[j-1\].key) /\*比较\*/  
\{ /\*r\[j\]与r\[j-1\]进行交换\*/  
r\[0\]=r\[j\];  
r\[j\]=r\[j-1\];  
r\[j-1\]=r\[0\];  
\}  
printf("成绩从低到高排列如下:/n");  
for (i=1;i<=n;i++)  
printf("%6d",r\[i\].key);  
printf("/n");  
for (i=1;i<=n;i++)  
printf("%6s",r\[i\].data);  
printf("/n");  
\}  
int main()  
\{  
elemnode s=\{0," ",75,"王华",87,"李英",68,"张萍",92,"陈涛",88,"刘丽",  
61,"章强",77,"孙军",96,"朱斌",80,"许伟",72,"曾亚"\};  
/\*s\[0\]元素不计入元素个数\*/  
int n=10;  
bubblesort(s,n);  
return 0;  
\}

[Link 1]: http://student.zjzk.cn/course_ware/data_structure/web/flashhtml/maopaopaixu.htm
[blob_key_2150266_filename_4.jpg]: /images/20220824/e53b3293542b40f1a4cb4c69c5afbac3.png