LeetCode刷题-04-排序

时间 2020-11-30

标签 java 算法数组函数优化设计 3d code blog 栏目 Java 繁體版

原文原文链接

第四讲排序

4.1 巨经典的排序算法

1. 冒泡排序（很简单）

平均时间复杂度 O(n^2) ，空间复杂度 O(1)，稳定java
基本思想算法
- 两个数比较大小，较大的数下沉，较小的数冒起来。
演示（图片来自菜鸟教程）数组

代码函数

/**
 * 冒泡排序
 * @param array 待排序的数组
 */
public static void bubbleSort(int[] array) {
    for(int i=0; i<array.length-1; i++){
        for(int j=array.length-1; j>i; j--){
            if(array[j] < array[j-1]){
                int temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
            }
        }
    }
}

2. 选择排序

平均时间复杂度 O(n^2) ，空间复杂度 O(1)，不稳定优化
基本思想ui
- 遍历数组，依次找到第 i 小的元素，而后把它和第i 个元素交换位置
演示设计

代码3d

/**
 * 选择排序
 * @param array 待排序的数组
 */
public static void selectSort(int[] array) {
    for(int i=0;i<array.length-1;i++){
        int minIndex = i;
        for(int j=i+1;j<array.length;j++){
            if(array[j]<array[minIndex]){
                minIndex = j;
            }
        }
        if(minIndex != i){
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
}

3. 插入排序

平均时间复杂度 O(n^2) ，空间复杂度 O(1)，稳定code
基本思想blog
- 在要排序的一组数中，假定前 i 个数已经排好序了，那么第 i+1 个数只须要插入到前面已经排好序的数组中便可
演示（图片来自菜鸟教程）

代码

/**
 * 插入排序
 * @param array 待排序的数组
 */
public void insertSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = i + 1; j > 0; j--) {
            if (array[j] < array[j-1]) {
                int temp = array[j-1];
                array[j-1] = array[j];
                array[j] = temp;
            } else {
                break;
            }
        }
    }
}

4. 归并排序

平均时间复杂度 O(n log(n)) ，空间复杂度 O(n)，稳定
基本思想（分治）
- 首先考虑如何合并两个有序数组
  - 咱们只须要依次比较两个数组中的第一个数便可，谁小放到新数组中
- 归并排序的主要思想就是归并两个有序数组。
  - 将原数组分红二组 A，B。若是A，B都是有序的，归并便可。
  - 可是A，B都不是有序的，那么就继续分。直到这个数组中只有1个数据的时候。
  - 这个时候能够认为他是有序的，而后依次向上合并
- 总结：递归分解数组，而后再从小到大合并
演示（图片来自菜鸟教程）

代码

/**
 * 归并排序
 * @param array 须要排序的数组
 * @return 排好序的数组
 */
public int[] mergeSort(int[] array) {
    // 建立额外的空间
    int[] res = Arrays.copyOf(array, array.length);
    if (res.length < 2) {
        return res;
    }
    int mid = array.length / 2;
    int[] left = Arrays.copyOfRange(array, 0, mid);
    int[] right = Arrays.copyOfRange(array, mid, array.length);
    return merge(mergeSort(left), mergeSort(right));
}

/**
 * 归并两个有序数组
 * @param array1 有序数组1
 * @param array2 有序数组2
 * @return 归并后的新数组
 */
private int[] merge(int[] array1, int[] array2) {
    int[] res = new int[array1.length + array2.length];
    int p = 0;
    int i = 0;
    int j = 0;
    while (i < array1.length && j < array2.length) {
        if (array1[i] <= array2[j]) {
            res[p++] = array1[i++];
        } else {
            res[p++] = array2[j++];
        }
    }
    // 剩下了left
    while (i < array1.length) {
        res[p++] = array1[i++];
    }
    // 剩下的是right
    while (j < array2.length) {
        res[p++] = array2[j++];
    }
    return res;
}

5. 快速排序（很经常使用）

平均时间复杂度 O(n log(n)) ，空间复杂度 O(log n)，不稳定
算法思想（分治）
- 选取一个key，对于比key大的，所有放到右边，对于比key小的，所有放到key的左边。这样key的位置就能够惟一肯定了。而后对key两边的区间重复操做就能够肯定全部元素的位置了
演示（图片来自菜鸟教程）
具体操做
1. i=0，j=n-1，key=array[i]
2. j 向前移动，找到第一个比 key 小的元素，把这个元素放到 i
3. i 向后移动，找到第一个比 key 大的元素，将它放到 j 的位置
4. 在 i 的地方放上 key
5. 通过这么一步操做，就可使得 [0,i-1] 中全部的元素都是比 i 小的，[j,n-1] 中的全部元素都是比 i 大的，而后重复操做，直到 i==j 这样就知足了 array[0,i-1] < array[i] < array[i+1,n-1] 。而后 i左右两边的区间重复操做。

代码

/**
 * @param array 须要排序区间所在的数组
 * @param left 区间的起始下标
 * @param right 区间的结束下标
 */
public void quickSort(int[] array, int left, int right) {
    if (left < right) {
        int i = left;
        int j = right;
        int key = array[left];
        while (i < j) {
            // 从j开始向左寻找到第一个比 key 小的数
            while (i < j && array[j] >= key) {
                j--;
            }
            if (i < j ) {
                array[i] = array[j];
                i++;
            }
            // 从i开始向右寻找第一个大于等于 key 的数
            while (i < j && array[i] < key) {
                i++;
            }
            if (i < j) {
                array[j] = array[i];
                j--;
            }
        }
        array[i] = key;
        quickSort(array, left, i-1);
        quickSort(array, i+1, right);
    }
}

6. 堆排序

平均时间复杂度 O(n+k) ，空间复杂度 O(k)，稳定
什么是堆？
- 堆是具备如下性质的彻底二叉树：每一个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每一个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。（注意是左右孩子而不是左右子树）
基本思想
- 将待排序的数组构形成一个大顶堆。此时，堆顶的元素就是最大的，将堆顶元素和最后一个元素交换位置，而后从新构造大顶堆。
- 咱们不须要想构造一颗二叉树同样去构造堆，咱们只须要按照如下规则进行对应便可：
  - 即数组下标为 i 的元素，他的左右孩子的下标是 2i+1 和 2i+2
- 如此一来，咱们就不须要额外的空间
演示

代码

/**
 * 堆排序
 * @param array 待排序的数组
 */
public void heapSort(int[] array) {
    // len表示的是未进行排序的长度
    int len = array.length;
    for (int i = 0; i < array.length; i++) {
        // 从最后一个非叶子节点开始调整，使其知足大顶堆的性质
        int last = len / 2 - 1;
        for (int j = last; j >= 0; j--) {
            int left = 2 * j + 1;
            int right = left + 1;
            if (array[left] > array[j]) {
                swap(array, left, j);
            }
            if (right < len && array[right] > array[j]) {
                swap(array, right, j);
            }
        }
        len--;
        // 将堆顶元素和放到正确的地方
        swap(array, 0, array.length - 1 - i);
    }
}

/**
 * 交换数组中的两个元素
 * @param array 数组
 * @param i1 元素1
 * @param i2 元素2
 */
private void swap(int[] array, int i1, int i2) {
    int temp =  array[i1];
    array[i1] = array[i2];
    array[i2] = temp;
}

7. 计数排序

平均时间复杂度 O(n+k) ，空间复杂度 O(k)，稳定。其中，k是整数的范围
基本思想
- 遍历数组，得出最大值、最小值、差距三者中的两个。
- 申请一个新数组，数组长度为差距。而后对原数组中的数进行遍历，记录出现的次数
- 最后遍历新数组，就能够获得排序后的结果
演示

代码

/**
 * 计数排序
 * @param array 待排序的数组
 */
public void countingSort(int[] array) {
    int min = array[0];
    int max = array[0];
    // 找最大值和最小值
    for (int i : array) {
        min = Math.min(i, min);
        max = Math.max(i, max);
    }

    // 申请额外的空间，大小为最值之间的范围
    int[] temp = new int[max - min + 1];

    // 填充新数组
    for (int i : array) {
        temp[i - min]++;
    }

    // 遍历新数组，而后填充原数组
    int index = 0;
    for (int i = 0; i < temp.length; i++) {
        if (temp[i] != 0) {
            Arrays.fill(array, index, index + temp[i], i + min);
            index += temp[i];
        }
    }
}

注意：计数排序对于必定范围内的整数进行排序具备最高的效率，前提是整数的范围不要太大

8. 桶排序

平均时间复杂度 O(n) ，空间复杂度 O(n+k)，稳定。其中k是桶的数量
基本思想
- 首先划分若干个范围相同的 “桶” ，
- 而后将待排序的数据扔到属于他本身的桶中
- 对桶中的数据进行排序
- 依次输出全部桶中的数据
关键
- 计数排序的优化，适合于对于大量有范围的数据
- 桶的划分要尽可能保证元素应当能够均匀分散到全部桶中，若是说全部元素都集中在一个桶中，那么桶排序就会失效
演示
代码
- 桶排序的关键在于桶的划分和选取。须要根据实际使用场景按需进行设计，因此这里不作展现。

4.2 快速选择

215. 数组中的第K个最大元素（Medium）

思路
- 快速选择算法是快速排序的一个变形
- 从上文对于快速排序的讲解中不难发现。对于一个 key 来讲，在进行一次快速排序的过程当中，是能够肯定出这个 key 所在有序数组中的位置。
- 那么咱们只须要关注这个位置是否是咱们须要的 K 便可。若是比 k 大，则在 key 的右边再作一次快速排序便可；反之，则在左边作一次快速排序
时间复杂度 O(n)，空间复杂度 O(1)

代码

public int findKthLargest(int[] nums, int k) {
    int left = 0;
    int right = nums.length - 1;
    int target = nums.length - k;
    while (left < right) {
        int p = quickSort(nums, left, right);
        if (p < target) {
            left = p + 1;
        } else if (p > target) {
            right = p - 1;
        } else {
            return nums[p];
        }
    }
    return nums[left];
}

// 快速排序函数，返回key的下标
public int quickSort(int[] array, int left, int right) {
    int i = left;
    int j = right;
    int key = array[left];
    while (i < j) {
        while (i < j && array[j] >= key) {
            j--;
        }
        if (i < j) {
            array[i] = array[j];
            i++;
        }
        while (i < j && array[i] < key) {
            i++;
        }
        if (i < j) {
            array[j] = array[i];
            j--;
        }
    }
    array[i] = key;
    return i;
}

注意点
- 当 k=1 时，函数可能不会在循环体中返回结果。此时，退出循环后left=5 ，因此要返回 nums[left]

4.3 桶排序

347. 前 K 个高频元素（Medium）

思路
- 典型的桶排序的使用场景，来回顾一下桶排序
  - 桶排序就是把须要排序的元素放到属于他的桶中，而后再对桶中的元素进行排序，最后把所用桶中的元素输出就是排序以后的结果。重点是让全部元素均匀的分布到全部桶中
- 若是咱们的桶中只放这个元素本身，那么桶的大小就是这个元素的出现次数，而后根据桶的大小进行排序，就能够很方便的获得出现频率前K个高频元素
- 重点：将元素和出现频率进行对应
- 时间 O(n log(n))，空间 O(n)

代码

public int[] topKFrequent(int[] nums, int k) {
    int[] res = new int[k];
    // 用哈希表作桶排序，每一个元素做为key，出现次数做为value
    Map<Integer, Integer> map = new HashMap<>();
    for (int num : nums) {
        map.put(num, map.getOrDefault(num, 0)+1);
    }
    int[][] bucket = new int[map.size()][2];
    int p = 0;
    // 利用数组将元素和出现次数进行对应
    for (Integer i : map.keySet()) {
        bucket[p][0] = i;
        bucket[p++][1] = map.get(i);
    }
    // 降序排序
    Arrays.sort(bucket, ((o1, o2) -> o2[1]-o1[1]));
    for (int i = 0; i < k; i++) {
        res[i] = bucket[i][0];
    }
    return res;
}

优化
- 在获得每一个元素的频率以后，能够再对频率进行一次桶排序，这样的话能够把时间复杂度下降到 O(n)

代码

// 再对频率进行一次桶排序，这样就能够获得前K个高频的元素
// 对于频率最高的元素，放在最前面
List<Integer>[] bucket = new List[maxFrequency + 1];
for (int i : map.keySet()) {
    int f = maxFrequency - map.get(i);
    if (bucket[f] == null) {
        bucket[f] = new ArrayList<>();
    }
    bucket[f].add(i);
}
List<Integer> res = new ArrayList<>();
int i = 0;
while (k > 0) {
    List<Integer> list = bucket[i++];
    if (list != null) {
        res.addAll(list);
        k -= list.size();
    }
}

4.4 基础练习

451. 根据字符出现频率排序（Medium）

思路
- 桶排序，每一个字母一个桶，最后降序输出

代码

public String frequencySort(String s) {
    Map<Character, Integer> map = new HashMap<>();
    // 对字母进行桶排序，获得每一个字母出现的频率
    int max = 0;
    for (int i = 0; i < s.length(); i++) {
        map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
        max = Math.max(max, map.get(s.charAt(i)));
    }
    // 再对频率进行一次桶排序
    ArrayList<Character>[] bucket = new ArrayList[max + 1];
    for (char c : map.keySet()) {
        int f = map.get(c);
        if (bucket[f] == null) {
            bucket[f] = new ArrayList<>();
        }
        bucket[f].add(c);
    }
    int p = 0;
    char[] chars = s.toCharArray();
    for (int i = max; i >= 0; i--) {
        if (bucket[i] != null) {
            for (char c : bucket[i]) {
                Arrays.fill(chars, p, p+i, c);
                p += i;
            }
        }
    }
    return new String(chars);
}

4.5 进阶练习

75. 颜色分类（Medium）

思路
- 遍历数组，对三种颜色出现的次数进行统计，而后填充数组

代码

public void sortColors(int[] nums) {
    int[] f = new int[3];
    for (int num : nums) {
        f[num]++;
    }
    int p = 0;
    for (int i = 0; i < 3; i++) {
        Arrays.fill(nums, p, p + f[i], i);
        p += f[i];
    }
}

LeetCode刷题-04-排序

第四讲 排序

4.1 巨经典的排序算法

1. 冒泡排序（很简单）

2. 选择排序

3. 插入排序

4. 归并排序

5. 快速排序（很经常使用）

6. 堆排序

7. 计数排序

8. 桶排序

4.2 快速选择

215. 数组中的第K个最大元素（Medium）

4.3 桶排序

347. 前 K 个高频元素（Medium）

4.4 基础练习

451. 根据字符出现频率排序（Medium）

4.5 进阶练习

75. 颜色分类（Medium）

第四讲排序