排序问题总结 - CSNotes

最新推荐文章于 2022-03-14 22:32:23 发布

原创最新推荐文章于 2022-03-14 22:32:23 发布 · 145 阅读

0 ·

CC 4.0 BY-SA版权

刷题同时被 3 个专栏收录

51 篇文章

订阅专栏

python

40 篇文章

订阅专栏

面试查缺补漏

15 篇文章

订阅专栏

本文介绍了如何使用堆排序（最小堆和最大堆）及快速选择算法寻找数组中的第K大或第K小元素。堆排序在不同情况下选择不同的堆类型，快速选择通过随机化pivot实现高效查找。两种方法的时间复杂度分析也进行了说明。

补充：堆排序（升序，降序，迭代，递归写法）
https://blog.youkuaiyun.com/unspoken0714/article/details/107921229

第K大的元素或者第K个最大元素

可用堆排或快速选择（快排+二分）的解法。

堆排：
第K大的元素用最小堆或最大堆，冒K次，时间复杂度 = 建堆时间+调整堆k次 = O（n）+ O（Klogn）
第K个最大元素用最大堆或最小堆，冒K次，时间复杂度一样

在这里插入图片描述
如果是用迭代实现堆的heapify，空间复杂度为O（1），堆排序是原地排序。

import java.util.PriorityQueue;

public class Solution {

    // 根据 k 的不同，选最大堆和最小堆，目的是让堆中的元素更小
    // 思路 1：k 要是更靠近 0 的话，此时 k 是一个较小的数，用最大堆
    // 例如在一个有 6 个元素的数组里找第 5 大的元素
    // 思路 2：k 要是更靠近 len 的话，用最小堆

    // 所以分界点就是 k = len - k

    public int findKthLargest(int[] nums, int k) {
        int len = nums.length;
        if (k <= len - k) {
            // System.out.println("使用最小堆");
            // 特例：k = 1，用容量为 k 的最小堆
            // 使用一个含有 k 个元素的最小堆
            PriorityQueue<Integer> minHeap = new PriorityQueue<>(k, (a, b) -> a - b);
            for (int i = 0; i < k; i++) {
                minHeap.add(nums[i]);
            }
            for (int i = k; i < len; i++) {
                // 看一眼，不拿出，因为有可能没有必要替换
                Integer topEle = minHeap.peek();
                // 只要当前遍历的元素比堆顶元素大，堆顶弹出，遍历的元素进去
                if (nums[i] > topEle) {
                    minHeap.poll();
                    minHeap.add(nums[i]);
                }
            }
            return minHeap.peek();

        } else {
            // System.out.println("使用最大堆");
            assert k > len - k;
            // 特例：k = 100，用容量为 len - k + 1 的最大堆
            int capacity = len - k + 1;
            PriorityQueue<Integer> maxHeap = new PriorityQueue<>(capacity, (a, b) -> b - a);
            for (int i = 0; i < capacity; i++) {
                maxHeap.add(nums[i]);
            }
            for (int i = capacity; i < len; i++) {
                // 看一眼，不拿出，因为有可能没有必要替换
                Integer topEle = maxHeap.peek();
                // 只要当前遍历的元素比堆顶元素大，堆顶弹出，遍历的元素进去
                if (nums[i] < topEle) {
                    maxHeap.poll();
                    maxHeap.add(nums[i]);
                }
            }
            return maxHeap.peek();
        }
    }
}

快速选择：
每次partition找到选出的pivot最终的正确位置，将pivot的位置和k（第K大的元素）或len（nums）- k （第K个最大元素）比较，若pivot大，则去左边区间 < pivot 递归，若pivot小，则去右边区间 > pivot 递归。

本题必须随机初始化 pivot 元素（或选择 nums[i], nums[j], nums[(i+j)/2] 的中位数），否则通过时间会很慢，因为测试用例中有极端测试用例（基本正序或基本逆序），即每次递归都会分成两个区间，一个长度为1，一个长度为len（nums）-1.

from typing import List
import random


class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        size = len(nums)

        target = size - k
        left = 0
        right = size - 1
        while True:
            index = self.__partition(nums, left, right)
            if index == target:
                return nums[index]
            elif index < target:
                # 下一轮在 [index + 1, right] 里找
                left = index + 1
            else:
                right = index - 1

    #  循环不变量：[left + 1, j] < pivot
    #  (j, i) >= pivot
    def __partition(self, nums, left, right):

        pivot = nums[left]
        j = left
        for i in range(left + 1, right + 1):
            if nums[i] < pivot:
                j += 1
                nums[i], nums[j] = nums[j], nums[i]

        nums[left], nums[j] = nums[j], nums[left]
        return j

时间复杂度分析：

O(f(n))，给出了算法运行时间的上界，也就是最坏情况下的时间复杂度；

Ω(f(n))，给出了算法运行时间的下界，也就是最好情况下的时间复杂度；

Θ(f(n))，给出了算法运行时间的上界和下界，这里Θ(f(n))是渐近的确界，并非所有的算法都有Θ(f(n))。

在这里插入图片描述

时间复杂度：O(N)，这里 N 是数组的长度
空间复杂度：O(1)，原地排序，没有借助额外的辅助空间

分析：
快排的时间复杂度我觉得是T(n) = T(n/2) + n，首先不是一个完全的递归树，按照每次排序刚好定位到中间来想，递归树的下一层只有T(n/2)，不考虑另一半；其次，每一层递归树都要遍历对应的, "分而治之"的”分“后的数组长度，所以+n 这样来算用Master method，T(n) = aT(n/b) + f(n), f(n) = n,a=1,b=2, f(n) = Ω(n的 (以b为底a的对数 + x) 次方 )，x>0, 所以T(n) = O(f(n))=O(n)