您的位置：首页 > 其它

排序算法----交换排序（冒泡排序，快速排序）

2011-05-10 19:28 751 查看

[转载]排序算法----交换排序（冒泡排序，快速排序）
2007-09-21 17:06

（1）网络字节序

htonl就是把本机字节顺序转化为网络字节顺序

所谓网络字节顺序（大尾顺序）就是指一个数在内存中存储的时候“高对低，低对高”（即一个数的高位字节存放于低地址单元，低位字节存放在高地址单元中）。但是计算机的内存存储数据时有可能是大尾顺序或者小尾顺序。

先举个例子：

int a = 0x403214;

int b = htonl(a);

我在VC++6.0调试这段代码，发现

&a的值为：0x0012ff44

其中0x0012ff44、0x0012ff45、0x0012ff46、0x0012ff47这四个单元的值依次为：14、32、40、00，即0x403214这个数的高位部分存放在高位地址中，低位部分存放在低位地址中，即小尾顺序。

&b的值为：0x0012ff40

其中0x0012ff40、0x0012ff41、0x0012ff42、0x0012ff43这四个单元的值依次为：00、40、32、14，即把原数0x403214的高位部分存放在低位地址中，低位部分存放在高位地址中。

由此可见，如果一个数以小尾顺序存储，经htonl函数调用后这个数的高地位字节会完全颠倒过来成为一个新的数。这个新的数在机器内部其实还是以小尾顺序存储的，但是相对于原来的数而言相当于是变成大尾顺序的了。

long型的0x40写完整为:0x 00 00 00 40，共四个字节，调用htonl后四个字节颠倒顺序，为0x 40 00 00 00。

同样，0x40 00 00 00调用htonl后变为0x 00 00 00 40，即0x40

例程：#include <stdio.h>

int main()

{

int aaa = 0x01;

printf("%d",htonl(aaa)); 输出为 0x01 00 00 00 即 1 00000000 00000000 00000000 =2 ^ 24=16777216

return 0;

}

　交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。

　应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法

　将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

（1）初始

　 R[1..n]为无序区。

（2）第一趟扫描

　从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R
，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的文件进行冒泡排序的过程【参见动画演示】

3、排序算法

（1）分析

　因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。

　若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。

（2）具体算法

#include <stdio.h>

void sort(int a[],int n)

{

int i,j,q,temp;

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

{

q=1;

for(j=0;j<n-i-1;j++)

{

if(a[j]>a[j+1])

{

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

q=0;

}

}

if(q==1)

{

return;

}

}

}

int main()

{

int a[10]={9,8,7,6,5,4,3,2,1,0};

int i;

sort(a,10);

printf("the out put is\n");

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

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

return 0;

}

4、算法分析

（1）算法的最好时间复杂度

　若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：

Cmin=n-1

Mmin=0。

　冒泡排序最好的时间复杂度为O(n)。

（2）算法的最坏时间复杂度

　若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

Cmax=n(n-1)/2=O(n2)

Mmax=3n(n-1)/2=O(n2)

　冒泡排序的最坏时间复杂度为O(n2)。

（3）算法的平均时间复杂度为O(n2)

　虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多。

（4）算法稳定性

　冒泡排序是就地排序，且它是稳定的。

5、算法改进

　上述的冒泡排序还可做如下的改进：

(1)记住最后一次交换发生位置lastExchange的冒泡排序

　　在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之前的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是有序区，R[lastExchange..n]是无序区。这样，一趟排序可能使当前有序区扩充多个记录，从而减少排序的趟数。具体算法【参见习题】。

(2) 改变扫描方向的冒泡排序

①冒泡排序的不对称性

　　能一趟扫描完成排序的情况：

　只有最轻的气泡位于R
的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序。

【例】对初始关键字序列12，18，42，44，45，67，94，10就仅需一趟扫描。

需要n-1趟扫描完成排序情况：

　当只有最重的气泡位于R[1]的位置，其余的气泡均已排好序时，则仍需做n-1趟扫描才能完成排序。

【例】对初始关键字序列：94，10，12，18，42，44，45，67就需七趟扫描。

②造成不对称性的原因

　　每趟扫描仅能使最重气泡"下沉"一个位置，因此使位于顶端的最重气泡下沉到底部时，需做n-1趟扫描。

③改进不对称性的方法

　在排序过程中交替改变扫描方向，可改进不对称性。具体算法【参见习题】。
快速排序(QuickSort)

1、算法思想

　快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

（1）分治法的基本思想

　分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

（2）快速排序的基本思想

　设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：

①分解：

　在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

注意：

　划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])：

　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys

其中low≤pivotpos≤high。

②求解：

　通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

③组合：

　因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

2、快速排序算法QuickSort

void QuickSort(SeqList R，int low，int high)

{ //对R[low..high]快速排序

int pivotpos； //划分后的基准记录的位置

if(low<high){//仅当区间长度大于1时才须排序

pivotpos=Partition(R，low，high)； //对R[low..high]做划分

QuickSort(R，low，pivotpos-1)； //对左区间递归排序

QuickSort(R，pivotpos+1，high)； //对右区间递归排序

}

} //QuickSort

注意：

　为排序整个文件，只须调用QuickSort(R，1，n)即可完成对R[l..n]的排序。
3、划分算法Partition

（1）简单的划分方法

① 具体做法

　　第一步：(初始化)设置两个指针i和j，它们的初值分别为区间的下界和上界，即i=low，i=high；选取无序区的第一个记录R[i](即R[low])作为基准记录，并将它保存在变量pivot中；

　　第二步：令j自high起向左扫描，直到找到第1个关键字小于pivot.key的记录R[j]，将R[j])移至i所指的位置上，这相当于R[j]和基准R[i](即pivot)进行了交换，使关键字小于基准关键字pivot.key的记录移到了基准的左边，交换后R[j]中相当于是pivot；然后，令i指针自i+1位置开始向右扫描，直至找到第1个关键字大于pivot.key的记录R[i]，将R[i]移到i所指的位置上，这相当于交换了R[i]和基准R[j]，使关键字大于基准关键字的记录移到了基准的右边，交换后R[i]中又相当于存放了pivot；接着令指针j自位置j-1开始向左扫描，如此交替改变扫描方向，从两端各自往中间靠拢，直至i=j时，i便是基准pivot最终的位置，将pivot放在此位置上就完成了一次划分。

②一次划分过程

　一次划分过程中，具体变化情况【参见动画演示】

③划分算法：

int Partition(SeqList R，int i，int j)

{//调用Partition(R，low，high)时，对R[low..high]做划分，

//并返回基准记录的位置

ReceType pivot=R[i]； //用区间的第1个记录作为基准 '

while(i<j){ //从区间两端交替向中间扫描，直至i=j为止

while(i<j&&R[j].key>=pivot.key) //pivot相当于在位置i上

j--； //从右向左扫描，查找第1个关键字小于pivot.key的记录R[j]

if(i<j) //表示找到的R[j]的关键字<pivot.key

R[i++]=R[j]； //相当于交换R[i]和R[j]，交换后i指针加1

while(i<j&&R[i].key<=pivot.key) //pivot相当于在位置j上

i++； //从左向右扫描，查找第1个关键字大于pivot.key的记录R[i]

if(i<j) //表示找到了R[i]，使R[i].key>pivot.key

R[j--]=R[i]; //相当于交换R[i]和R[j]，交换后j指针减1

} //endwhile

R[i]=pivot； //基准记录已被最后定位

return i；

} //partition
实例：
#include <stdio.h>
int part(int a[],int i,int j)

{

int pos=a[i];

while(i<j){

while(i<j&&a[j]>=pos) j--;

if(i<j) a[i++]=a[j];

while(i<j&&a[i]<=pos) i++;

if(i<j) a[j--]=a[i];

}

a[i]=pos;

return i;

}

void quicksort(int a[], int low, int high)

{

int pos;

if(low<high){

pos=part(a,low,high);

quicksort(a,low,pos-1);

quicksort(a,pos+1,high);

}

}

int main()

{

int a[10]={29,48,7,16,325,4,3,22,112,40};

int i;

quicksort(a,0,9);

printf("the out put is\n");

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

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

return 0;

}

4、快速排序执行过程

　快速排序执行的全过程可用递归树来描述。

分析：

　（1）递归执行的路线如图中带箭头的包络线所示。

　（2）递归树上每一结点左旁方括号表示当前待排序的区间，结点内的关键字是划分的基准关键字

注意：

　叶结点对应的子区间只有一个关键字，无须划分，故叶结点内没有基准关键字

　　（3）划分后得到的左、右两个子区间分别标在该结点的左、右两个孩子结点的左边方括号内。

【例】根结点左旁方括号[49，38，65，97，76，13，27，49]表示初始待排序的关键字，根内的49表示所选的划分基准记录的关键字，划分结果是[27，28，13]49[76，97，65，49_]，其左右子区间分别标在根结点的两个孩子的左边。

　（4）每个分支结点右旁圆括号中的内容表示对该结点左旁区间的排序过程结束之后返回的结果。它是其左右孩子对应的区间排序完成之后，将左右孩子对应的排序结果分别放在该分支结点的关键字前后所得到的关键字序列。

【例】分支结点76的左右孩子对应的区间排序后的结果分别是(49_，65)和(97)，将它们分别放在76的前后即得(49，65，76，97)，这是对结点76左旁区间[76，97，，65，49]排序的结果。

　（5）算法的执行顺序是递归树中的箭头顺序，实际上当把划分操作视为访问结点的操作时，快速排序的执行过程相当于是先序遍历其递归树。

注意：

　任何递归算法均可用递归树来描述其执行过程。

5、快速排序各次划分后的状态变化

[49 38 65 97 76 13 27
49] //初始关键字

[27 38 13] 49[76 97 6549] //第1次划分完成之后，对应递归树第2层

[13] 27
[38] 49 [49 65] 76[97]//对上一层各无序区划分完成后，对应递归树第3层

13 27 38 49 49
[65] 76 97 //对上一层各无序区划分完成后，对应递归树第4层

13 27 38 49 49 65 76 97 //最后的排序结果
6、算法分析

　快速排序的时间主要耗费在划分操作上，对长度为k的区间进行划分，共需k-1次关键字的比较。

（1）最坏时间复杂度

　最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。

　因此，快速排序必须做n-1次划分，第i次划分开始时区间长度为n-i+1，所需的比较次数为n-i(1≤i≤n-1)，故总的比较次数达到最大值：

Cmax = n(n-1)/2=O(n2)

　如果按上面给出的划分算法，每次取当前无序区的第1个记录为基准，那么当文件的记录已按递增序(或递减序)排列时，每次划分所取的基准就是当前无序区中关键字最小(或最大)的记录，则快速排序所需的比较次数反而最多。

（2）最好时间复杂度

　在最好情况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：

0(nlgn)

注意：

　用递归树来分析最好情况下的比较次数更简单。因为每次划分后左、右子区间长度大致相等，故递归树的高度为O(lgn)，而递归树每一层上各结点所对应的划分过程中所需要的关键字比较次数总和不超过n，故整个排序过程所需要的关键字比较总次数C(n)=O(nlgn)。

　因为快速排序的记录移动次数不大于比较的次数，所以快速排序的最坏时间复杂度应为0(n2)，最好时间复杂度为O(nlgn)。

（3）基准关键字的选取

　在当前无序区中选取划分的基准关键字是决定算法性能的关键。

　　①"三者取中"的规则

　"三者取中"规则，即在当前区间里，将该区间首、尾和中间位置上的关键字比较，取三者之中值所对应的记录作为基准，在划分开始前将该基准记录和该区伺的第1个记录进行交换，此后的划分过程与上面所给的Partition算法完全相同。

　　②取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准

　选取基准最好的方法是用一个随机函数产生一个取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准，这相当于强迫R[low..high]中的记录是随机分布的。用此方法所得到的快速排序一般称为随机的快速排序。具体算法【参见教材】

注意：

　随机化的快速排序与一般的快速排序算法差别很小。但随机化后，算法的性能大大地提高了，尤其是对初始有序的文件，一般不可能导致最坏情况的发生。算法的随机化不仅仅适用于快速排序，也适用于其它需要数据随机分布的算法。

（4）平均时间复杂度

　尽管快速排序的最坏时间为O(n2)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为O(nlgn)。

（5）空间复杂度

　快速排序在系统内部需要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。

（6）稳定性

　快速排序是非稳定的，例如[2，2，1]

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航