排序算法

1. 插入类排序

1.1 直接插入排序

class Solution {
    public void insertSort(int[] arr, int n) {
        int tmp;
        for (int i = 1; i < n; i++) {
            // 将待插入的关键字暂存于tmp中
            tmp = arr[i];
            int j = i - 1;
            // 依次从待排关键字之前的关键字进行扫描
            while (j >= 0 && tmp < arr[j]) {
                arr[j + 1] = arr[j];
                --j;
            }
            // 找到插入位置
            arr[j + 1] = tmp;
        }
    }
}

时间复杂度

• 最坏情况：$O(n^2)$
• 最好情况：$O(n)$
• 平均时间复杂度：$O(n^2)$

2. 交换类排序

2.1 冒泡排序

class Solution {
    public void bubbleSort(int[] arr, int n) {
        boolean flag;
        int tmp;
        for (int i = n - 1; i >= 1; i--) {
            // 用flag标记本趟排序是否发生了交换
            flag = false;
            for (int j = 1; j <= i; j++) {
                if (arr[j - 1] > arr[j]) {
                    tmp = arr[j];
                    arr[j] = arr[j -1];
                    arr[j - 1] = tmp;
                    flag = true;
                }
            }
            if (!flag) {
                return;
            }
        }
    }
}

时间复杂度

• 最坏情况：$O(n^2)$
• 最好情况：$O(n)$
• 平均时间复杂度：$O(n^2)$

2.2 快速排序

class Solution {
    public void quickSort(int[] arr, int low, int high) {
        // 对从arr[low]到arr[high]的关键字进行排序
        int tmp;
        int i = low, j = high;
        if (low < high) {
            tmp = arr[low];
            // 将小于tmp的数放左边，将大于tmp的数放右边
            while (i < j) {
                // 从右往左扫描，找到一个小于tmp的数
                while (i < j && arr[j] >= tmp) {
                    --j;
                }
                if (i < j) {
                    arr[i] = arr[j];
                    ++i;
                }
                // 从左往右扫描，找到一个大于tmp的数
                while (i < j && arr[i] < tmp) {
                    ++i;
                }
                if (i < j) {
                    arr[j] = arr[i];
                    --j;
                }
                arr[i] = tmp;
                quickSort(arr, low, i - 1);
                quickSort(arr, i + 1, high);
            }
        }
    }
}

时间复杂度

• 最坏情况：$O(n^2)$
• 最好情况：$O(nlog_2n)$
• 平均时间复杂度：$O(nlog_2n)$

待排序列越接近无序，算法效率越高。

3. 选择类排序

3.1 简单选择排序

class Solution {
    public void selectSort(int[] arr, int n) {
        int tmp;
        for (int i = 0; i < n; i++) {
            int k = i;
            for (int j = i + 1; j < n; ++j) {
                if (arr[k] > arr[j]) {
                    k = j;
                }
            }
            tmp = arr[i];
            arr[i] = arr[k];
            arr[k] = tmp;
        }
    }
}

时间复杂度：$O(n^2)$