【LeetCode】3月20日打卡-Day5

題1 最小的k個數

描述

輸入整數數組 arr ，找出其中最小的 k 個數。例如，輸入4、5、1、6、2、7、3、8這8個數字，則最小的4個數字是1、2、3、4。
示例 1：
輸入：arr = [3,2,1], k = 2
輸出：[1,2] 或者 [2,1]
示例 2：
輸入：arr = [0,1,2,1], k = 1
輸出：[0]
限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

題解

思路：先快排，然後取前k個元素。
快排思想：遞歸，遞歸條件是i<j。與基準比較大小，小的在基準右邊，大的在基準左邊。最後將基準放於ij相遇處。先比較左邊再比較右邊。

class Solution {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基準位
        temp = arr[low];

        while (i<j) {
            //先看右邊，依次往左遞減
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左邊，依次往右遞增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果滿足條件則交換
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

        }
        //最後將基準爲與i和j相等位置的數字交換
        arr[low] = arr[i];
        arr[i] = temp;
        //遞歸調用左半數組
        quickSort(arr, low, j-1);
        //遞歸調用右半數組
        quickSort(arr, j+1, high);
    }

    public int[] getLeastNumbers(int[] arr, int k) {
        quickSort(arr,0,arr.length-1);
        int[] temp = new int[k]; 
        for (int i = 0; i < k; i++){
            temp[i] = arr[i];
        }
        return temp;
    }
}

題2

描述

在未排序的數組中找到第 k 個最大的元素。請注意，你需要找的是數組排序後的第 k 個最大的元素，而不是第 k 個不同的元素。
示例 1:
輸入: [3,2,1,5,6,4] 和 k = 2
輸出: 5
示例 2:
輸入: [3,2,3,1,2,4,5,5,6] 和 k = 4
輸出: 4
說明:
你可以假設 k 總是有效的，且 1 ≤ k ≤ 數組的長度。

題解1

思路類似於題1

class Solution {
    
    public void quickSort(int[] nums, int left, int right){
        if(left>right){
            return;
        }
        int i = left;
        int j = right;
        int pivot = nums[left];
        while(i<j){
            while(i<j&&nums[j]<=pivot){
                j--;
            }
            while(i<j&&nums[i]>=pivot){
                i++;
            }
            if(i<j){
                int tmp = nums[i];
                nums[i] = nums[j];
                nums[j] = tmp;
            }
        }
        nums[left] = nums[i];
        nums[i] = pivot;
        quickSort(nums,left,j-1);
        quickSort(nums,j+1,right);
    }
    public int findKthLargest(int[] nums, int k) {
        quickSort(nums, 0, nums.length-1);
        for(int i: nums){
            System.out.println(i);
        }
        return nums[k-1];
    }
}

題解2

思路：創建大頂堆，將所有元素加入堆中，保持堆的大小小於等於k，堆保留的元素就是前k個最大的元素，堆頂爲正確答案。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        // init heap 'the smallest element first'
        PriorityQueue<Integer> heap =
            new PriorityQueue<Integer>((n1, n2) -> n1 - n2);

        // keep k largest elements in the heap
        for (int n: nums) {
          heap.add(n);
          if (heap.size() > k)
            heap.poll();
        }

        // output
        return heap.poll();        
  }
}

class Solution:
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        return heapq.nlargest(k, nums)[-1]