排序算法总结

排序算法

时间复杂度	排序算法
O(n²)	冒泡、插入、选择
O(nlogn)	希尔、归并、快速、堆排序

时间复杂度O(n²)

冒泡排序

• 原地排序：空间复杂度为O(1)
• 稳定性：稳定的
• 时间复杂度：O(n²)

public class BubbleSort {

    private static void bubbleSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        // i是冒泡次数:n个数最多需要比较冒泡n-1次
        for (int i = 0; i < arr.length - 1; i++) {
            boolean isSwap = false;
            // 从前往后冒泡比较
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 交换相邻的两个元素，大数往后冒泡
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    isSwap = true;
                }
            }
            if (!isSwap) {
                break;
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

插入排序

• 原地排序：空间复杂度为O(1)
• 稳定性：稳定的
• 时间复杂度：O(n²)

public class InsertionSort {

    public static void insertSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        // 插入排序：初试将数组分为已排序区间(第1个元素)、未排序区间(从第2个元素到末尾)
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            // 查找插入的位置
            for (; j >= 0; j--) {
                // <=就停止循环
                if (arr[j] <= temp) {
                    break;
                }
                // >就后移元素
                arr[j + 1] = arr[j];
            }
            // j+1下一个位置放temp
            arr[j + 1] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 5, 6, 1, 3, 2};
        InsertionSort.insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

• 原地排序：空间复杂度为O(1)
• 稳定性：不稳定的
• 时间复杂度：O(n²)

public class SelectionSort {

    private static void selectSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        // 初始化：已排序区间(无)，未排序区间(0到n-1)
        for (int i = 0; i < arr.length - 1; i++) {
            // 选择排序是在未排序区间中找最小值下标
            int minIndex = i;
            for (int j = i; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            // 交换，这里的交换打破了稳定性
            swap(arr, i, minIndex);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

时间复杂度O(nlogn)

希尔排序

• 原地排序：空间复杂度为O(1)
• 稳定性：不稳定的,时间复杂度是插入排序的优化版,但是稳定性是不稳定的
• 时间复杂度：O(nlogn)

public class ShellSort {

    /**
     * 希尔排序
     * 不稳定，时间复杂度为NlogN
     */
    public static void shellSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        // 步长step
        int step = arr.length / 2;
        // 插入排序最低就是步长为1
        while (step >= 1) {
            // 以step为距离进行插入排序
            for (int i = step; i < arr.length; i += step) {
                int temp = arr[i];
                int j = i - step;
                for (; j >= 0; j -= step) {
                    if (arr[j] <= temp) {
                        break;
                    }
                    arr[j + step] = arr[j];
                }
                arr[j + step] = temp;
            }
            // 步长缩小
            step /= 2;
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 5, 6, 1, 3, 2};
        int[] arr1 = {4, 5, 6, 1, 3, 2};
        ShellSort.shellSort(arr);
        ShellSort.insertSort(arr1);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 插入排序
     * 稳定的、时间复杂度为N²
     */
    public static void insertSort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        // 插入排序：初试将数组分为已排序区间(第1个元素)、未排序区间(从第2个元素到末尾)
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            // 查找插入的位置
            for (; j >= 0; j--) {
                // <=就停止循环
                if (arr[j] <= temp) {
                    break;
                }
                // >就后移元素
                arr[j + 1] = arr[j];
            }
            // j+1下一个位置放temp
            arr[j + 1] = temp;
        }
    }
}

归并排序

• 原地排序：空间复杂度为O(n)
• 稳定性：稳定的
• 时间复杂度：O(nlogn)

public class Solution {

    private int res;

    /**
     * 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
     * 归并排序法，原理是利用nums[i]>nums[j],那么[i,mid]中都是逆序对个数
     */
    public int reversePairs(int[] nums) {
        int[] temp = new int[nums.length];
        res = 0;
        mergeSort(nums, 0, nums.length - 1, temp);
        return res;
    }

    private void mergeSort(int[] nums, int l, int r, int[] temp) {
        if (l >= r) {
            return;
        }
        int mid = l + (r - l) / 2;
        mergeSort(nums, l, mid, temp);
        mergeSort(nums, mid + 1, r, temp);
        if (nums[mid] > nums[mid + 1]) {
            merge(nums, l, mid, r, temp);
        }
    }

    private void merge(int[] nums, int l, int mid, int r, int[] temp) {
        System.arraycopy(nums, l, temp, l, r - l + 1);
        int p = l, q = mid + 1;
        for (int i = l; i <= r; i++) {
            if (p > mid) {
                nums[i] = temp[q++];
            } else if (q > r) {
                nums[i] = temp[p++];
            } else if (temp[p] <= temp[q]) {
                // <=区域不会形成逆序对,所以和归并排序过程一样
                nums[i] = temp[p++];
            } else {
                // 3,4,1,2
                // p到mid中间元素的个数，与q构成逆序对
                res += mid - p + 1;
                nums[i] = temp[q++];
            }
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] arr = {3, 4, 1, 2};
        System.out.println(solution.reversePairs(arr));
    }

}

快速排序

• 原地排序：空间复杂度为O(logn)
• 稳定性：不稳定的
• 时间复杂度：O(nlogn)

public class QuickSort {
    /**
     * 快速排序
     * 与寻找第k大的数做比较
     */
    public static void quickSort(int[] arr) {
        // random作为参数一致传递下去
        Random random = new Random();
        quickSort(arr, 0, arr.length - 1, random);
    }

    private static void quickSort(int[] arr, int l, int r, Random random) {
        // 递归结束条件:显然只剩一个数时,递归结束
        if (l >= r) {
            return;
        }
        // 先划分区间
        int p = partition(arr, l, r, random);
        // 左边递归排序
        quickSort(arr, l, p - 1, random);
        // 右边递归排序
        quickSort(arr, p + 1, r, random);
    }

    /**
     * 原地分区函数
     */
    private static int partition(int[] arr, int l, int r, Random random) {
        int p = l + random.nextInt(r - l + 1);
        // p位置元数移动到l位置，让交换后的arr[l]作为基准，划分数组
        swap(arr, l, p);

        int i = l + 1, j = r;
        while (true) {
            while (i <= j && arr[i] < arr[l]) {
                i++;
            }
            while (i <= j && arr[j] > arr[l]) {
                j--;
            }
            if (i >= j) {
                break;
            }
            swap(arr, i, j);
            i++;
            j--;
        }
        // 由于i++,j--操作，j指向<=arr[p]的最后一个位置，交换j和l位置元素
        swap(arr, l, j);
        return j;
    }

    private static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

比较学习：查找数组中第k大的数

public class Solution {

    /**
     * 查找数组中第k大的数
     */
    public int findKth(int[] a, int n, int K) {
        if (a == null || a.length == 0 || a.length < K) {
            return -1;
        }
        return quickSortK(a, n, K, 0, n - 1);
    }

    private int quickSortK(int[] arr, int n, int k, int l, int r) {
        int i = l;
        int j = r;
        while (i < j) {
            // 这里以arr[l]为基准，必须先走j，因为j先走一步的话，会先来到<arr[l]的最后一个数，此时交换i，j位置就不会出错
            // 如果以arr[r]为基准，必须先走i，因为i先走一步的话，会先来到>arr[l]的最后一个数，此时交换i，j位置就不会出错
            while (i < j && arr[j] >= arr[l]) {
                j--;
            }
            while (i < j && arr[i] <= arr[l]) {
                i++;
            }
            swap(arr, i, j);
        }
        swap(arr, i, l);
        // 快排使得数组从小到大排序
        // 第1大的数 = 第n-1洗标的数
        // 第k大的数 = 第n-k下标的数
        if (i == n - k) {
            return arr[i];
        } else if (i < n - k) {// <,左边界前进
            return quickSortK(arr, n, k, i + 1, r);
        } else {// >,右边界后退
            return quickSortK(arr, n, k, l, i - 1);
        }
    }

    private void swap(int[] arr, int i, int j) {
        if (i == j) {
            return;
        }
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] arr = {10, 10, 9, 9, 8, 7, 5, 6, 4, 3, 4, 2};
        int n = arr.length;
        int k = 3;
        int res = solution.findKth(arr, n, k);
        System.out.println(res);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序

• 建立大根堆

public class MaxHeapSort {

    // 大根堆
    public static void heapSort(int[] arr) {
        if (arr.length < 2) {
            return;
        }
        // 从最右子树开始建立大根堆，堆顶保持最小值
        for (int parent = (arr.length - 2) / 2; parent >= 0; parent--) {
            heapify(arr, parent, arr.length);
        }
        // 大根堆依次将堆顶元素放回数组末尾
        for (int i = arr.length - 1; i >= 0; i--) {
            swap(arr, 0, i);
            heapify(arr, 0, i);
        }
    }

    // 大根堆，堆化操作
    private static void heapify(int[] arr, int parent, int n) {
        while (2 * parent + 1 < n) {
            int left = 2 * parent + 1;
            if (left + 1 < n && arr[left + 1] < arr[left]) {
                left++;
            }
            if (arr[parent] <= arr[left]) {
                break;
            }
            swap(arr, parent, left);
            parent = left;
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {4, 5, 1, 6, 6};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

• 建立小根堆

public class MinHeapSort {

    // 小根堆
    public static void heapSort(int[] arr) {
        if (arr.length < 2) {
            return;
        }
        // 小根堆，堆顶保持最大值
        for (int parent = (arr.length - 2) / 2; parent >= 0; parent--) {
            heapify(arr, parent, arr.length);
        }
        // 将堆顶最大值依次放回数组末尾
        for (int i = arr.length - 1; i >= 0; i--) {
            swap(arr, 0, i);
            heapify(arr, 0, i);
        }
    }


    private static void heapify(int[] arr, int parent, int n) {
        while (2 * parent + 1 < n) {
            int left = 2 * parent + 1;
            if (left + 1 < n && arr[left + 1] > arr[left]) {
                left++;
            }
            if (arr[parent] >= arr[left]) {
                break;
            }
            swap(arr, parent, left);
            parent = left;
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {4, 5, 1, 6, 6};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}