[Swift]LeetCode215. 数组中的第K个最大元素 | Kth Largest Element in an Array

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10197956.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Example 1:

Input: [3,2,1,5,6,4] and k = 2
Output: 5

Example 2:

Input: [3,2,3,1,2,4,5,5,6] and k = 4
Output: 4

Note: 
You may assume k is always valid, 1 ≤ k ≤ array's length.

---

在未排序的数组中找到第 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 ≤ 数组的长度。

---

24ms

class Solution {
    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
        return nums.sorted(by: >)[k - 1]
    }
}

---

56ms

class Solution {
    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
      var newNums = nums
        buildMaxHead(&newNums)//建最大堆
        for i in ((newNums.count - k - 1)..<newNums.count).reversed() {
            swap(&newNums, 0, i)
            if i == newNums.count - k {
                return newNums[i]
            }
            headify(&newNums, 0, i)
        }
        return 0
    }
    //MARK: 堆排序
    func headSort(_ nums:inout [Int]) {
        buildMaxHead(&nums)
        for i in (1..<nums.count).reversed() {
            swap(&nums, i, 0)
            headify(&nums, 0, i)
        }
    }
    //建最大堆
    func buildMaxHead(_ nums:inout [Int]) {
        for i in (0...nums.count/2).reversed() {
            headify(&nums, i,nums.count)
        }
    }
    //堆调整
    func headify(_ nums:inout [Int], _ index: Int, _ length: Int) {
        let leftChild = index * 2 + 1 // index节点的左孩子节点
        let rightChild = index * 2 + 2 //index节点的右孩子节点
        var largertIndex = index //节点与左右孩子的最大值
        if leftChild < length && nums[leftChild] > nums[largertIndex] {
            largertIndex = leftChild
        }
        if rightChild < length && nums[rightChild] > nums[largertIndex] {
            largertIndex = rightChild
        }
        //如果交换了
        if largertIndex != index {
            swap(&nums, largertIndex, index)//交换节点值
            headify(&nums, largertIndex,length)//调整变动的节点
        }
    }
        func swap(_ nums:inout [Int],_ i:Int,_ j: Int) {
        let temp = nums[i]
        nums[i] = nums[j]
        nums[j] = temp
    }
}

---

56ms

class Solution {
    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
        var nums = nums
        return find(&nums, 0, nums.count - 1, k)
    }

    func find(_ nums: inout [Int], _ start: Int, _ end: Int, _ k: Int) -> Int {
        let pivot = partition(&nums, start, end)
        let j = nums.count - pivot
        if j > k {
            return find(&nums, pivot + 1, end, k)
        }
        if j == k {
            return nums[pivot]
        }
        return find(&nums, start, pivot - 1, k)
    }

    func partition(_ nums: inout [Int], _ start: Int, _ end: Int) -> Int {
        guard start < end else {
            return start
        }
        let pivot = Int.random(in: start...end)
        nums.swapAt(pivot, end)
        var index = start
        for i in start..<end where nums[i] < nums[end] {
            nums.swapAt(i, index)
            index += 1
        }
        nums.swapAt(index, end)
        return index
    }
}

---

60ms

class Solution {
    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
        var arr = nums
        return quickselect(arr: &arr, start: 0, end: arr.count - 1, k: arr.count - k)
    }
   
    private func quickselect(arr: inout[Int], start: Int, end: Int, k: Int) -> Int {
        let pivot = partition(arr: &arr, start: start, end: end)
        if pivot > k { return quickselect(arr: &arr, start: start, end: pivot - 1, k: k) }
        if pivot == k { return arr[pivot] }
        return quickselect(arr: &arr, start: pivot + 1, end: end, k: k)
    }

    private func partition(arr: inout[Int], start: Int, end: Int) -> Int {
        guard start < end else { return start }
        
        var i = start
        let pivotIndex = Int.random(in: start ... end)
        let pivot  = arr[pivotIndex]
        (arr[pivotIndex], arr[end]) = (arr[end], arr[pivotIndex])
        
        for j in start ..< end {
            if arr[j] < pivot {
                (arr[i], arr[j]) = (arr[j], arr[i])
                i += 1
            }
        }
        
        (arr[i], arr[end]) = (arr[end], arr[i])
        return i
    }
    
}

---

84ms

class Solution {
    private var heapSize = 0
    
    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
        guard nums.count > 0 else {
            return 0
        }
        var nums = nums
        buildMaxHeap(&nums)
        var i = 0
        while i < k - 1 {
            swap(&nums, 0, heapSize - 1)
            heapSize -= 1
            maxHeapAdjust(&nums, 0)
            i += 1
        }
        return nums[0]
    }
    
    func buildMaxHeap(_ nums: inout [Int]) {
        heapSize = nums.count
        var i = heapSize >> 1 - 1
        while i >= 0 {
            maxHeapAdjust(&nums, i)
            i -= 1
        }
    }
    
    func maxHeapAdjust(_ nums: inout [Int],_ index: Int) {
        var largest = index
        var l = index << 1 + 1
        var r = index << 1 + 2
        if l < heapSize && nums[l] > nums[largest] {
            largest = l
        }
        if r < heapSize && nums[r] > nums[largest] {
            largest = r
        }
        if largest != index {
            swap(&nums, largest, index)
            maxHeapAdjust(&nums, largest)
        }
    }
    
    func swap(_ nums: inout [Int], _ i: Int,_ j: Int) {
        let temp = nums[i]
        nums[i] = nums[j]
        nums[j] = temp
    }
}