深入浅出交换类排序算法（转）

　1）冒泡排序

　　冒泡排序在众多排序算法中算比较简单的一个，基本思想是重复的进行整个数列的排序，一次比较两个元素(两两排序)，如果它们顺序不符合就交换，重复这样直到数列没有再需要交换的数为止(结束条件)。就好像气泡一样，轻的气泡会往上漂浮，在不断漂浮的过程中，发生了两两交换过程，所以叫冒泡排序。

　　其实也可以用生活中的例子理解，就比如: 在军训排队时，按个子高的和个子矮的的顺序进行排列，个子高的和个子矮的会进行两两进行比较。

　　我们来大致看下算法的流程:

　　选一组序列 4, 3 , 5, 6, 2, 1 (极端情况)

　　从头开始进行冒泡排序，1号和2号进行交换，4 > 3, 所以需要进行交换:

　　-> 3, 4, 5, 6, 2, 1

　　2号和3号进行交换，4<5，不交换

　　-> 3, 4, 5, 6, 2, 1

　　3号和4号进行交换，5<6，不交换

　　-> 3, 4, 5, 6, 2, 1

　　4号和5号进行交换，6>2，交换

　　-> 3, 4, 5, 2, 6, 1

　　5号和6号进行交换，6>1，交换

　　-> 3, 4, 5, 2, 1, 6

　　第一轮冒泡排序结束，把最大的数交换到最后一位，如此循环，直到没有需要交换的元素为止，冒泡排序才结束。

　　代码实现如下:

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

void BubbletSort(int*a,int len) {

    int m;

    for (bool bSwap=true; bSwap; len--) {

        bSwap = false;

        for (int j=1;j<len;j++) {

            if (a[j-1]>a[j]) {   // 交换值

                m=a[j];

                a[j]=a[j-1];

                a[j-1]=m;

                bSwap=true;

            }

        }

    }

}

　　其实冒泡排序整体看来是非常"傻"的，有很多可以优化的余地。比方说，每次比较如果发现较小的元素在后面，就交换两个相邻的元素，而如果我只扫描元素，记下最小元素，等一次扫描完后，再交换两者为止，这样最小元素就排到了前面，每扫描一次，只需要一次真正的交换，而刚才的冒泡可能需要交换多次，刚才说的算法优化其实就是选择排序，以后我会细说，他属于选择排序的范畴。

　　我们来考虑下冒泡算法的复杂度:

　　在时间复杂度上，若待排序的序列为完全逆序，则每次都需要进行元素之间的交换，所以时间复杂度为O(   )，若待排序为顺序，也就是不需要交换元素，但是需要扫描，所以还是需要O()的时间复杂度，平均情况下时间复杂度为O() 。

　　在空间复杂度上，需要辅助空间只有一个m(如上面代码)，所以空间复杂度为O(1)。

　　2) 快速排序

　　如果大家还记得折半插入排序的过程：在一个有序序列中，插入关键字和折半序列的中间关键字进行比较，若小则在关键字左边，若大则在关键字右边。而快速排序和折半插入排序有异曲同工之妙，差别在于折半插入排序插入的序列自身是个有序序列，选取中间关键字时两边已经有序。而快速排序在于它不一定是有序的，它的操作过程是：随便选取一个关键字(一般选取第一个)，让所有关键字和它进行比较一次，小的放在左边，大的放在它右边，然后递归地对左边和右边进行排序。把该区间内的所有数依次与关键字比较，我们就可以在线性的时间里完成分割的操作。

　　我们来看下算法的步骤:

　　初始状态：            【49，38，65，97，76，13，27，49‘】
　　一次划分后：         【27，38，13】 49 【76，97，65，49‘】
　　分别进行快速排序:  【13】 27 【38】 【49‘，65】76【97】
　　有序序列:             【13，27，38，49，49‘，65，76，97】

　　上面是算法的大致步骤，一般完成分割操作有很多有技巧性的实现方法，比如最常用的一种是定义两个指针，一个从前往后找找到比关键字大的，一个从后往前找到比关键字小的，然后两个指针对应的元素交换位置并继续移动指针重复刚才的过程。这只是大致的方法，具体的实现还有很多细节问题。

　　我们来看一下一轮快排序的细节步骤:

　　原始序列(i和j分别指向序列的最低和最高位置)：

　　选取第一个数49作为比较排序关键字。

　　1、使用j,从序列最右端开始扫描遇到比49小的则停止。

　　2、将27交换到i的位置

　　3、使用i，从序列最左端开始扫描遇到比49大的数则停止

　　4、将65交换到j的位置

　　5、再使用j向前扫描遇到比49小的13停止，并把13交换到i位置。

　　6、使用i向后扫描遇到比49大的97停止，并交换到j的位置

　　7、继续使用j向前扫描遇到比49小的并停止，这时发现i和j相遇，代表扫描结束。

　　8、最后把49放置在ij的位置

　　从上面的一轮快排可以看出，49把整个序列划分为两个部分，小于49的在它左边，大于49的在它右边。根据算法思想再分别把49两边的序列进行快排一次。另外从整个排序过程来看，先对整个序列进行一次快排，然后再对其中子序列再进行快排，如此反复直到有序为止，整个过程是个递归的思想。所以代码比较好写，我们来实现一下。

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

// head=>序列的开头

// tail=>序列的结尾

void quickSort(int array[], int head, int tail) {

    if (head > tail) {

        return;

    }

    // i,j指向头和尾巴

    int i=head;

    int j=tail;

    int iPivot=array[i]; /**< 选取枢轴 */

    while (i<j) {

        // 使用j,从序列最右端开始扫描,直到遇到比枢轴小的数

        while ((i<j) && (iPivot <= array[j])) {

            j--;

        }

        // 交换位置

        if (i<j) {

            array[i++]=array[j];

        }

        // 使用i,从序列最左端开始扫描,直到遇到比枢轴小的数枢轴大的数

        while ( (i<j) && (array[i] <= iPivot) ) {

            i++;

        }

        // 交换位置

        if (i<j) {

            array[j--]=array[i];

        }

    }

    // 最后填入枢轴位置

    array[j]=iPivot;

    // 这里就是对枢轴两边序列进行排序的递归调用

    quickSort(array, head, i-1);

    quickSort(array, i+1, tail);

}

　　代码已经严格测试过，一般不会有问题。下面我们来看下时间复杂度和空间复杂度。

　　快速排序有个特点，待排序列越接近无序，算法效率越高，也就是在基本有序的情况下时间复杂度为O()，最好情况下为O(  )，平均复杂度为O(  )，从所有内排序来看，快排是所有内排序中平均复杂度最好的，另外空间复杂度也为O( )。因为上面的算法实现是递归进行的，递归需要栈空间。

http://kb.cnblogs.com/page/185060/

时间： 2024-11-10 00:54:12

深入浅出交换类排序算法（转）的相关文章

交换类排序算法

#include<stdio.h> /* *交换类排序,每天一道算法题 *按照从小到大的顺序进行排序 * 毛施平 */ //冒泡排序 void traverseArray(int *p,int length) { int i=0; for(;i<length;i++) { printf("%d\n",p[i]); } } //这个是最简单的 void bubbleSortOne(int *p,int length) { int i=length; int j,temp

常见的五类排序算法图解和实现（多关键字排序：基数排序以及各个排序算法的总结）

基数排序思想 完全不同于以前的排序算法,可以说,基数排序也叫做多关键字排序,基数排序是一种借助“多关键字排序”的思想来实现“单关键字排序”的内部排序算法. 两种方式: 1.最高位优先,先按照最高位排成若干子序列,再对子序列按照次高位排序 2.最低位优先:不必分子序列,每次排序全体元素都参与,不比较,而是通过分配+收集的方式. 多关键字排序 例:将下表所示的学生成绩单按数学成绩的等级由高到低排序,数学成绩相同的学生再按英语成绩的高低等级排序.        第一个关键字是数学成绩,第二个关键字是英

基于相邻元素交换的排序算法的下界

逆序(inversion)是指序列中具有性质“i<j,但a[i]>a[j]“的序偶(a[i].a[j]). 例如:在序列34,8,64,51,32,21中具有9个逆序:(34,8),(34,32),(34,21),(64,51),(64,32),(64,21),(51,32),(51,21),(32,21): 显而易见的是,排序完成之后,序列中将不会存在逆序.因此我们可以通过计算序列中的逆序数来及算排序平均运行时间的精确的界.为了可以定义出“平均”,这里假设序列中不存在重复元素.利用这个假设,

交换类排序：冒泡，快速（递归与非递归）

<pre name="code" class="cpp">交换类排序:1:冒泡排序O(n^2),空间复杂度O(1) 2:快速排序O(n乘以log以2为底,n的对数),空间复杂度O(log以2为底,n的对数) //冒泡排序 void BubbleSort(int R[],int n) { int i,j,tmp,flag; for(i=0;i<n-1;i++) { flag=0; for(j=n-1;j>i;j--) { if(R[j]<

数据结构之排序算法Java实现（4）—— 交换类排序之快速排序算法

快速排序算法属于"交换类"的排序,它的效率主要跟数据分布是否对称有关. 升序排序: /** * 快速排序 * 升序排序 */ @Override public <T extends Comparable<? super T>> void sortByAsc(T[] data) { if(data == null || data.length <= 1){ return; } partitionSortByAsc(data, 0, data.length -

详谈排序算法之交换类排序（两种方法实现快速排序【思路一致】）

1.冒泡排序    起泡排序的思想非常简单.首先,将 n 个元素中的第一个和第二个进行比较,如果两个元素的位置为逆序,则交换两个元素的位置:进而比较第二个和第三个元素关键字,如此类推,直到比较第 n-1 个元素和第 n 个元素为止:上述过程描述了起泡排序的第一趟排序过程,在第一趟排序过程中,我们将关键字最大的元素通过交换操作放到了具有 n 个元素的序列的最一个位置上.然后进行第二趟排序,在第二趟排序过程中对元素序列的前 n-1 个元素进行相同操作,其结果是将关键字次大的元素通过交换放到第 n-1

常见的五类排序算法图解和实现（交换类：冒泡排序，递归的快速排序）

冒泡排序算法: 总的来说就是两两交换,反复直到有序,第一个记录和第二个记录,若逆序则交换,然后比较第二个和第三个记录,以此类推,直到第 n 个记录和第 n-1个记录比较完毕为止,第一趟排序,结果关键字最大的记录被安排在最后一个位置.对前 n-1个记录继续冒泡排序,使得关键字次大的记录安排在第 n-1个位置.如此重复,直到没有需要交换的记录为止(仅仅是第一个和第二个交换过为止).整个一趟趟的选出最值的过程,仿佛是那水里的气泡,咕嘟咕嘟的往上翻的过程. 递增冒泡排序过程图解: 一般先比较第一个元素和

三、基于交换的排序算法（冒泡排序和快速排序）

1.冒泡排序 基本思想:若从小到大排序,从头开始,两两比较,大的放在后面,将待排序元素从左到右比较一遍成为“一次冒泡”,每次冒泡都将待排序数列中最大的关键字交换到最后,直到所有元素有序为止. 算法复杂度:O(2^n) 改进方法:可能排序几次后,数列已经有序,但是还没有进行完n次循环.可以在交换的代码段中设置一个标志位,如果该标志位改变说明有交换(还未有序),否则用break退出循环. //1.冒泡排序 //注意数组下标溢出 void Bubble(int *array, int n) { int

常见排序算法——七大比较类排序算法

算法 最坏复杂度 平均复杂度 最好复杂度 空间复杂度 选择排序 O($n^2$) O($n^2$) O($n^2$) O(1) 插入排序 O($n^2$) O($n^2$) O($n$) O(1) 希尔排序 O($nlog(n))$~O($n^2$) O($n^{1.3}$) O($n^2$) O(1) 冒泡排序 O($n^2$) O($n^2$) O(n)(用交换flag改进) O(1) 快速排序 O($n^2$) O($nlog(n)$) O($nlog(n)$) O(log(n))~O(n