冒泡排序、插入排序、选择排序

稳定的排序算法：冒泡、插入、归并

不稳定的排序算法：选择、快速、堆排序

---

冒泡排序，O(n²)，O(1)，稳定

  冒泡排序对相邻的两个元素进行比较，看是否满足大小关系。如果不满足就让它俩互换。每轮冒泡操作都会让至少一个元素移动到它应该在的位置，最多重复 n 次，就完成了 n 个元素的排序工作。

    public void bubbleSort(int[] a) {
        int n = a.length;
        if (n <= 1) {
            return;
        }
        for (int i = 0; i < n; ++i) {
            boolean flag = false;
            for (int j = 0; j < n - i - 1; ++j) {
                if (a[j] > a[j + 1]) { // 交换
                    int tmp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = tmp;
                    flag = true; // 表示有数据交换
                }
            }
            if (!flag) {
                break; // 没有数据交换，提前退出
            }
        }
    }

  

插入排序，O(n²)，O(1)，稳定

  将数组中的数据分为已排序区间和未排序区间。挨个取未排序区间中的元素，在已排序区间中找到合适的位置进行插入，并保证已排序区间中的元素一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

    public void insertSort(int[] a) {
        int n = a.length;
        if (n <= 1) {
            return;
        }
        for (int i = 1; i < n; i++) {
            int tmp = a[i];
            int j = i - 1;
            while (j >= 0 && a[j] > tmp) {
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = tmp;
        }
    }

  

冒泡排序和插入排序的时间复杂度、空间复杂度、是否稳定都一模一样。为什么一般使用插入排序而不是冒泡排序呢？

因为冒泡排序的数据交换要比插入排序的数据移动要复杂，冒泡排序有三次赋值操作，而插入排序只有一次赋值操作，而它们排序过程中移动次数都与逆序度有关，所以相同情况下插入排序耗时更少。
  

选择排序，O(n²)，O(1)，不稳定

  选择排序算法的实现思路类似插入排序：将数组中的数据分为已排序区间和未排序区间，每次从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

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