5种常见排序算法

一、冒泡排序（Bubble Sort）

只会操作相邻的两个数据，每次比较相邻的数据大小，不符合要求，就进行一次数据移动，一次冒泡会至少让一个元素处于正确的位置，冒泡n次后，数据符合要求。冒泡排序只会移动相邻元素的变动。

是否是稳定排序：是

是否是原地排序：是

最好情况时间复杂度：O(n)

最坏情况时间复杂度：O(n^2)

平均情况时间复杂度：O(n^2)

代码实现：

public static void bubbleSort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            // 提前标识位
            boolean flag = false;
            for (int j = 0; j < a.length - i -1; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j+1] = temp;
                    flag = true;
                }
            }

            if (!flag) {
                // 没有数据交换提前退出
                break;
            }
        }
    }

二、插入排序（Insertion Sort）

就是将数据一个个插入到指定位置的排序算法；对于一个静态的数组，可以分为已排序区间和未排序区间，初始的排序区间为1，其排序流程就是将未排序区间中的元素，插入到已排序区间中。

是否是稳定排序：是

是否是原地排序：是

最好情况时间复杂度：O(n)

最坏情况时间复杂度：O(n^2)

平均情况时间复杂度：O(n^2)

代码实现：

public static void insertionSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            int value = a[i];
            int j = i - 1;
            for (; j >= 0; --j) {
                if (a[j] > value) {
                    a[j+1] = a[j];
                } else {
                    break;
                }
            }
            a[j + 1] = value;
        }
    }

三、选择排序（Selection Sort）

也是分已排序空间和未排序空间，但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

是否是稳定排序：是

是否是原地排序：否

最好情况时间复杂度：O(n)

最坏情况时间复杂度：O(n^2)

平均情况时间复杂度：O(n^2)

代码实现：

public static void selectionSort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int minIndex = i;
            for (int j = i; j < a.length - 1; j++) {
                if (a[j] < a[minIndex]) {
                    minIndex = j;
                }
            }

            // 进行数据的交换
            int temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }
    }

四、归并排序

就是将需要排序的数组，先从中间分成两部分，对着两部分进行排序后，在将排序后的两个数组进行合并，最后这个新的数组就是有序的了。归并排序采用的思想就是分治，将大问题拆解为小问题，最后再将小问题就行合并；也就是先分，后合。

是否是稳定排序：是

是否是原地排序：否，空间复杂度为O(n)

最好情况时间复杂度：O(nlogn)

最坏情况时间复杂度：O(nlogn)

平均情况时间复杂度：O(nlogn)

代码实现：

public static void mergeSort(int[] a, int p, int r) {
        // 递归终止条件
        if (p >= r) {
            return;
        }
        // 取p和r的中间值
        int q = p + (r - p)/2;
        mergeSort(a, p, q);
        mergeSort(a, q + 1, r);

        merge(a, p, q, r);

    }

    private static void merge(int[] a, int p, int q, int r) {
        int i = p;
        int j = q+1;
        int k = 0; // 初始化变量i, j, k
        int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组
        while (i<=q && j<=r) {
            if (a[i] <= a[j]) {
                tmp[k++] = a[i++]; // i++等于i:=i+1
            } else {
                tmp[k++] = a[j++];
            }
        }

        // 判断哪个子数组中有剩余的数据
        int start = i;
        int end = q;
        if (j <= r) {
            start = j;
            end = r;
        }

        // 将剩余的数据拷贝到临时数组tmp
        while (start <= end) {
            tmp[k++] = a[start++];
        }

        // 将tmp中的数组拷贝回a[p...r]
        for (i = 0; i <= r-p; ++i) {
            a[p+i] = tmp[i];
        }
    }

五、快速排序

从需要排序的数组下标q和r之间，选择一个数据作为pivot（分区点）。然后遍历q和r的数据，将小于pivot的数据放在pivot的左边，大于pivot的数据放在右边，这样数组就被分成三个部分小于pivot的数据，pivot数据，大于pivot的数据，重复上述步骤直到区间到1，完成排序。

是否是稳定排序：否

是否是原地排序：是

最好情况时间复杂度：O(nlogn)

最坏情况时间复杂度：O(n^2)

平均情况时间复杂度：O(nlogn)

代码实现：

public static void quickSort(int[] a, int p, int r) {
        if (p >= r) {
            return;
        }
        int q = partition(a, p, r); // 获取分区点
        quickSort(a, p, q-1);
        quickSort(a, q+1, r);
    }

    private static int partition(int[] a, int p, int r) {
        int pivot = a[r];
        int i = p;
        for(int j = p; j < r; ++j) {
            if (a[j] < pivot) {
                if (i == j) {
                    ++i;
                } else {
                    int tmp = a[i];
                    a[i++] = a[j];
                    a[j] = tmp;
                }
            }
        }

        int tmp = a[i];
        a[i] = a[r];
        a[r] = tmp;

        System.out.println("i=" + i);
        return i;
    }