leetcode215数组中的第K个最大元素

codeTop 微软刷题

题目链接
这道题考查最基本的排序功能，看能不能写出来

快速排序

private final Random random = new Random();

    public int findKthLargest(int[] nums, int k) {
        return randomPartition(nums, 0, nums.length - 1, nums.length - k);
    }

    //平均情况下快速排序的时间复杂度是Θ(𝑛\lgn)，最坏情况是Θ(𝑛2)。
    //当划分产生的两个子问题分别包含 n-1 和 0 个元素时，最坏情况发生。划分操作的时间复杂度为Θ(𝑛)，𝑇(0)=Θ(1)，这时算法运行时间的递归式为 𝑇(𝑛)=𝑇(𝑛−1)+𝑇(0)+Θ(𝑛)=𝑇(𝑛−1)+Θ(𝑛)，解为𝑇(𝑛)=Θ(𝑛2)。
    //当划分产生的两个子问题分别包含⌊𝑛/2⌋和⌈𝑛/2⌉−1个元素时，最好情况发生。算法运行时间递归式为 𝑇(𝑛)=2𝑇(𝑛/2)+Θ(𝑛)，解为𝑇(𝑛)=Θ(𝑛lg𝑛)。
    //事实上只要划分是常数比例的，算法的运行时间总是𝑂(𝑛lg𝑛)。 假设按照 9:1 划分，每层代价最多为 cn，递归深度为 log10/9𝑛=Θ(lg𝑛)，故排序的总代价为𝑂(𝑛lg𝑛)。
    //引入随机函数的作用就是为了防止最坏情况的发生
    public int randomPartition(int[] arr, int left, int right, int k) {
        //注意这里要+1
        int index = random.nextInt(right - left + 1) + left;
        swap(arr, index, right);
        int partition = partition(arr, left, right);
        if (partition == k) {
            return arr[partition];
        } else {
            return partition < k ? randomPartition(arr, partition + 1, right, k) : randomPartition(arr, left, partition - 1, k);
        }
    }

    public int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int end = left;
        for (int i = left; i < right; i++) {
            if (arr[i] <= pivot) {
                swap(arr, i, end++);
            }
        }
        swap(arr, end, right);
        return end;
    }

    public void swap(int[] arr, int left, int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

堆排序

public int findKthLargest(int[] nums, int k) {
            buildMaxHeap(nums);
            int length = nums.length - 1;
            //执行（k - 1）次操作
            for (int i = 1; i < k; i++) {
                swap(nums, 0, length);
                length--;
                adjustHeap(nums, 0, length);
            }
            return nums[0];
        }

        public void buildMaxHeap(int[] nums) {
            int length = nums.length;
            for (int i = length / 2; i >= 0; i--) {
                adjustHeap(nums, i, length);
            }
        }

        public void adjustHeap(int[] nums, int index, int length) {
            int left = 2 * index + 1;
            int right = 2 * index + 2;
            int pivot = index;
            //注意数组下标溢出
            if (left < length && nums[left] > nums[pivot]) {
                pivot = left;
            }
            if (right < length && nums[right] > nums[pivot]) {
                pivot = right;
            }
            if (pivot != index) {
                swap(nums, index, pivot);
                adjustHeap(nums, pivot, length);
            }
        }

        public void swap(int[] arr, int left, int right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }