[数据结构]七种排序算法小结

眼看着就要实习，为了巩固基础，回顾并总结排序算法。参考自：http://www.nowcoder.com/courses/1/1/1

冒泡排序

时间复杂度 o(n2) 。下面以一个例子来看什么是冒泡排序。
例：

第一次取区间[0,7]，通过比较第i个和第i+1个的大小，如果第i+1个数字小于第i个，则互换。这样位置7就是最大的数了。
第二次取区间[0,6]，通过比较第i个和第i+1个的大小，如果第i+1个数字小于第i个，则互换。这样位置6就是第二大的数了。
依次往下，可以得到排序，这就是冒泡排序。

选择排序

时间复杂度 o(n2) 。还是以上面的例子来说明。
第一次取区间[0,7],选择该区间最小的数和位置0的数进行交换；
第二次取区间[1,7],选择该区间最小的数和位置1的数进行交换；
第三次取区间[2,7],选择该区间最小的数和位置2的数进行交换；
依次往下，可以得到排序，这就是选择排序。

插入排序

时间复杂度 o(n2) 。以上面的例子来说明。
第一次将位置0和位置1进行比较，小的放前。
第二次将位置2上的数字，插入到位置0和位置1中（按照顺序）。
…
第k次将位置k上的数字，插入到第k-1次已经完成的序列中。
这就是插入排序。

归并排序

时间复杂度为 o(N×LogN) 。归并排序的思想是将两个顺序序列合并成一个顺序序列的方法。参考自归并排序_百度百科

设有数列{6，202，100，301，38，8，1}
初始状态：6,202,100,301,38,8,1
第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；
第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；
第三次归并后：{1,6,8,38,100,202,301},比较次数：4；
总的比较次数为：3+4+4=11；

快速排序

快速排序的时间复杂度是 o(N×LogN) 。它是对冒泡排序的一种改进。

首先在序列中随机选取一个数字，将大于该数字的放在其右边，小于该数字的放在左边。对于该数字左、右边的序列递归调用该过程。
其过程描述如下（来源自牛客网）

快排的JAVA实现

参考了MoreWindows的白话经典算法系列之六，自己实现了一下JAVA版本的快排，代码如下。

public class QuickSort {

    public static int getMiddle(int low, int high, Integer[] list) {
        int tmp = list[low];// 选择第一个数作为基准
        while (low < high) {
            while (list[high] >tmp && high > low) {// 找到后面大于基准的数
                high--;
            }
            if (low < high) {// 插入到空白处
                list[low] = list[high];
                low++;
            }
            while (list[low] <= tmp && low < high) {
                low++;
            }
            if (low < high) {
                list[high] = list[low];
                high--;
            }
        }
        list[low] = tmp;
        return low;
    }

    public static void quick(Integer[] x, int low, int high) {
        if (high > low) {
            int middle = getMiddle(low, high, x);
            System.out.println("本次基准是：" + middle);
            quick(x, low, middle - 1);
            quick(x, middle + 1, high);
        }
    }

    public static void main(String[] args) {
        Integer[] test = { 1, 3, 2 };
        Integer[] test1 = { 1, 2, 2 };
        Integer[] test2 = { 1000, 2, 2,34,11,222,11,33,2};
        quick(test, 0, 2);
        for (int i = 0; i < 3; i++)
            System.out.print("排序结果:"+test[i]+"  ");
        System.out.println();
        quick(test1, 0, 2);
        for (int i = 0; i < 3; i++) {
            System.out.print("排序结果:"+test1[i]+"  ");
        }
        System.out.println();
        quick(test2, 0, 8);
        for (int i = 0; i < 9; i++) {
            System.out.print("排序结果:"+test2[i]+"  ");
        }
    }
}

笔者又自行根据思路实现了一次C++版本的快排，可以参考。

快排的C++实现

#include
using namespace std;

//

void quick_sort(int s[],int begin,int end)
{
    if(begin>end)
        return ;
    int jizhun=s[begin];
    int keng=begin;
    bool flag=false;
    while(!flag)
    {
        flag=true;
        for(int i=end;i>keng;i--)//从右到左找小的
        {
            if(s[i]false;
                break;
            }
        }
        for(int i=begin;i//从左到右找大的
        {
            if(s[i]>jizhun)
            {
                s[keng]=s[i];
                keng=i;
                flag=false;
                break;
            }
        }
    }
    s[keng]=jizhun;
    quick_sort(s,begin,keng-1);
    quick_sort(s,keng+1,end);
}

int main()
{
    int b[9]={1000,2,2,34,11,222,11,33,2};
    quick_sort(b,0,8);
    for(int i=0;i<9;i++)
        cout<" ";
    cout<return 0;
}

堆排序

堆排序的时间复杂度是 o(N×LogN) 。要理解堆排序，首先应该要明白的概念是堆。可以参考博文白话经典算法系列之七 堆与堆排序。
二叉堆的定义

二叉堆是完全二叉树或者是近似完全二叉树。

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆（大根堆）。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆（小根堆）。

堆排序其实就是将大根堆的堆顶删除，再构造大根堆，依次下去即可。

希尔排序

希尔排序的时间复杂度是 o(N×LogN) 。希尔排序（参考博文白话经典算法之三 希尔排序的实现）是插入排序的一个改进。希尔排序是非稳定排序算法，实质就是分组插入排序，该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。
该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。
百度图片上找到一个例子，供参考。