排序算法总结

1、冒泡排序

1.1、冒泡排序的基本思想

从无序队列的头部开始（当然也可以从尾部开始，两两比较，将最小的数交换到队首），从前往后，将相邻的两个数进行两两比较，根据大小交换位置，将最大的数交换到无序数列的队尾，从而成为有序数列的一部分。下一次继续这个过程，直到将无序数列变成有序数列。

如下图所示，每次都把最大的数浮动到队列的末尾：

1.2、java代码实现

package BubbleSort;

public class BubbleSort {
    public void bubblesort(int[] array){
        if (array == null || array.length == 0)
            return ;
        for(int i = 0; i < array.length - 1; i++){

            //设定一个标记flag,若为true,则表示此次循环没有交换，也就是待排列顺序已有序，排序已完成
            boolean flag = true;

            //从队首开始，将大的数字向后排
            for (int j = 0; j < array.length - i - 1; j++){
                if (array[j] > array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    flag = false;
                }
            }
            if (flag)
                break;
        }
    }

    public static void main(String[] args) {
        BubbleSort bubbleSort = new BubbleSort();

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

        bubbleSort.bubblesort(array);
        //遍历array数组
        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


执行结果：
0 1 2 3 4 5 6 7 8 9 

1.3、性能分析

时间复杂度

根据上面这种冒泡实现，若原数组本身就是有序的（最理想情况），仅需n-1次比较就可以完成，时间复杂度为O（n）；如果是倒序，比较次数为：（n-1）+（n-2）+...+1=n（n-1）/ 2，所以其时间复杂度仍为O（n^2）。

空间复杂度

冒泡排序过程中需要一个临时变量来进行两两交换，所需的额外空间为1，因此空间复杂度为O（1）。

稳定性

冒泡排序在排序过程中，元素两两交换，相同元素的前后顺序没有改变，所以冒泡排序是一种稳定算法。

2、插入排序

2.1、插入排序的基本思想

插入排序的基本思想就是从第一个元素开始（该元素可以默认为已经排好序），每一步将一个待排序的记录，按照顺序插入到前面已经排好序的数列中去，直到插完所有的数。

如下图所示，中括号内代表已经排好序的数列：

2.2、java代码实现

package SortDemo;

public class InsertSort {
    public void sort(int[] array){
        for (int i = 1; i < array.length; i++){
            int j = i;
            while (j > 0 && array[j] < array[j-1]){
                int temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
                j--;
            }
        }
    }

    public static void main(String[] args) {
        InsertSort insertSort = new InsertSort();

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

        insertSort.sort(array);

        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


执行结果：0 1 2 3 4 5 6 7 8 9 

2.3、性能分析

时间复杂度

最理想情况下，数组为正序数组，需要比较n-1次，无需交换元素，时间复杂度为O（n）；

在最坏情况下，比较次数为1+2+...(n-2)+(n-1)=n(n-1)/2，时间复杂度仍为O（n^2）。

3、选择排序

3.1、选择排序的基本思想

选择排序是排序算法中最简单直观的一种算法，基本思想为每一趟从待排序的数列中，每次取出最小的一个数（或最大）作为首元素，直到所有元素排完为止。

在算法实现中，每一趟都要通过不断地交换来保证首位置为当前最小，交换是个很耗时的操作。其实很容易发现，在还未完全确定当前最小元素之前，这些交换都是没有意义的。因此我们可以设置一个参数min，用来保存当前比较下最小的数的下标，等最小数完全确定下来后，再执行交换操作。

如下图所示：

3.2、java代码实现

package SortDemo;
//选择排序
public class SelectSort {
    public void sort(int[] array){
        if (array == null || array.length == 0)
            return ;
        for (int i = 0; i < array.length - 1; i++){
            int min = i;
            for (int j = i + 1; j < array.length; j++){
                if (array[j] < array[min]){
                    min = j;
                }
            }
            if (min != i){
                int temp = array[min];
                array[min] = array[i];
                array[i] = temp;
            }
        }
    }

    public static void main(String[] args) {
        SelectSort selectSort = new SelectSort();

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

        selectSort.sort(array);

        for (int x : array){
            System.out.print(x + " ");
        }
    }
}

3.3、性能分析

时间复杂度

选择排序经过上面这种优化以后，无论数组是如何排列的，比较次数是不变的；

对于交换次数，在最好的情况下也就是数组完全有序的时候，无需任何交换移动，在最差情况下，也就是数组倒叙的时候，交换次数为n-1次，综合下来，时间复杂度为O（n^2）。

4、桶排序

4.1、桶排序的基本思想

桶排序的基本思想其实类似于分治思想，将数列中的数按照一定的规律分散到多个桶中，然后将每个桶中的数按照顺序排列好，最后再依次输出。

例如现在有一个无序的、长度为1000的数组，我们怎么用桶排序来将其排好顺序呢？可以分成以下几步：

1. 确定分配函数f(x)，将1000个数分配到多个桶中（理论上来说，我们应该使这1000个数均匀分配，但是实际上我们很难做到这一点）。如果是已知输入范围为【0,1000】的话，我们采取最简单的分配方法，即f(x)=x/100。
2. 按照分配函数f(x)，将1000个数分配到多个桶中后，在每个桶中对数据进行排序。
3. 待每个桶中的数据都排序好了以后，我们将桶按顺序输出。

如下图所示，我就以10个数为例，数的输入范围是【0,100】，分配函数f(x)=x/10：

4.2、java代码实现

package SortDemo;

public class BucketSort {
    public void sort(int[] array){
        //使用的分桶函数是f(x)=x/10
        //测试数据数值范围都是【0,100】

        //定义十个桶
        int bucketCount = 10;
        Integer[][] bucket = new Integer[bucketCount][array.length];
        for (int i = 0; i < array.length; i++){
            //通过f(x)确定数据放入哪个桶中
            int temp = array[i]/10;
            for (int j = 0; j < array.length; j++){
                if (bucket[temp][j] == null){
                    bucket[temp][j] = array[i];
                    break;
                }
            }
        }

        //小桶排序
        for (int i = 0; i < bucket.length; i++){
            //每个小桶内都使用插入排序算法
            for (int j = 1; j < bucket[i].length; j++){
                if (bucket[i][j] == null)
                    break;
                int k = j;
                while (k > 0 && bucket[i][k] < bucket[i][k-1]){
                    int x = bucket[i][k-1];
                    bucket[i][k-1] = bucket[i][k];
                    bucket[i][k] = x;
                    k--;
                }
            }
        }

        //将桶排序输出
        for (int i = 0, index = 0; i < bucket.length; i++){
            for (int j = 0; j < bucket[i].length; j++){
                if (bucket[i][j] != null){
                    array[index] = bucket[i][j];
                    index++;
                }
                else{
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        BucketSort bucketSort = new BucketSort();

        int[] array = {2,9,45,67,32,14,0,5,53,65,1};

        bucketSort.sort(array);

        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


执行结果：
0 1 2 5 9 14 32 45 53 65 67 

4.3、性能分析

时间复杂度

桶排序的时间复杂度可以从每一步分开进行分析：

1. 分桶的过程：遍历每个元素、进行f(x)计算，将x放入桶中，总共3n此操作，复杂度为O（n）；
2. 最后一步输出也是O（n）的复杂度；
3. 关键是小桶内排序的过程，我们应当使数据在分桶的时候分的更加平均，不至于使得某个小桶中数量极多；如果我们使用更多的桶，那无疑能够减少每个桶内的数据量，但是更多的桶会造成严重的空间损耗，这就要权衡空间复杂度问题了。
4. 总结起来，假设数据有n个，桶有m个，则桶排序的平均复杂度为：O(n)+O(n)+O(n/m)*log(n/m)=O(n+n*logn-n*logm)，最优情况下，桶排序的时间复杂度为O(n)。

空间复杂度

桶排序的空间复杂度是比较高的，额外开销为O(n+m)。