[Swift]LeetCode703. 数据流中的第K大元素 | Kth Largest Element in a Stream

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

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Your KthLargest class will have a constructor which accepts an integer k and an integer array nums, which contains initial elements from the stream. For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.

Example:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

Note: 
You may assume that nums' length ≥ k-1 and k ≥ 1.

---

设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。

你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。

示例:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

说明: 
你可以假设 nums 的长度≥ k-1 且k ≥ 1。

---

188ms

class KthLargest {
    var queue: PriorityQueue
    var k: Int
    
    init(_ k: Int, _ nums: [Int]) {
        self.queue = PriorityQueue()
        self.k = k
        
        for val in nums {
            self.queue.enqueue(val)
        }
        
        var temp = nums.count - k
        while temp > 0 {
            self.queue.dequeue()
            temp -= 1
        }
    }
    
    func add(_ val: Int) -> Int {
        queue.enqueue(val)
        if queue.array.count > k {
            queue.dequeue()
        }
        return queue.peek()!
    }
}

struct PriorityQueue {
    var array = [Int]()
    
    func peek() -> Int? {
        return array.first
    }
    
    mutating func enqueue(_ num: Int) {
        array.append(num)
        siftUp()
    }
    
    mutating func dequeue() {
        array.swapAt(0, array.count - 1)
        array.removeLast()
        siftDown()
    }
    
    mutating func siftDown() {
        var pIndex = 0
        var sLIndex = 0
        var sRIndex = 0
        var index = 0
        
        while pIndex * 2 + 1 <= array.count - 1  {
            sLIndex = pIndex * 2 + 1
            sRIndex = pIndex * 2 + 2
            index = pIndex
            
            if array[pIndex] > array[sLIndex] {
                index = sLIndex
            }
            
            if sRIndex <= array.count - 1 && array[index] > array[sRIndex] {
                index = sRIndex
            }
            
            if (pIndex != index) {
                array.swapAt(pIndex, index)
                pIndex = index
            } else {
                return
            }
        }
    }
    
    mutating func siftUp() {
        var pIndex = 0
        var sIndex = array.count - 1
        
        while sIndex != 0 {
            pIndex = (sIndex - 1) / 2
            if (array[sIndex] < array[pIndex]) {
                array.swapAt(sIndex, pIndex)
                sIndex = pIndex
            } else {
                return
            }
        }
    }
}

---

204ms

class KthLargest {

    let k:Int
    let heap = MinHeap()
    
    init(_ k: Int, _ nums: [Int]) {
        self.k = k
        for n in nums{
            self.heap.add(n)
            if self.heap.count > k{
                _ = self.heap.poll()
            }
        }
    }
    
    func add(_ val: Int) -> Int {
        if self.heap.count < k{
            self.heap.add(val)
            return self.heap.peek()!
        }
        if val <= self.heap.peek()!{
            return self.heap.peek()!
        }
        _ = self.heap.poll()
        self.heap.add(val)
        return self.heap.peek()!
    }
}

class MinHeap{
    
    var data:[Int] = [Int]()
    
    func parentIndex(_ index:Int) -> Int{
        return (index - 1) / 2
    }
    
    func leftChildIndex(_ index:Int) -> Int{
        return index * 2 + 1
    }
    
    func rightChildIndex(_ index:Int) -> Int{
        return index * 2 + 2
    }
    
    func parent(_ index:Int) -> Int{
        return self.data[self.parentIndex(index)]
    }
    
    func leftChild(_ index:Int) -> Int{
        return self.data[self.leftChildIndex(index)]
    }
    
    func rightChild(_ index:Int) -> Int{
        return self.data[self.rightChildIndex(index)]
    }
    
    func hasParent(_ index:Int) -> Bool{
        return self.parentIndex(index) >= 0
    }
    
    func hasLeftChild(_ index:Int) -> Bool{
        return self.leftChildIndex(index) < self.data.count
    }
    
    func hasRightChild(_ index:Int) -> Bool{
        return self.rightChildIndex(index) < self.data.count
    }
    
    func peek() -> Int?{
        return self.data.first
    }
    
    func poll() -> Int{
        let first = self.data[0]
        self.data[0] = self.data[self.data.count - 1]
        self.data.removeLast()
        if self.data.count > 1{
            self.heapifyDown()
        }
        return first
    }
    
    func add(_ item:Int){
        self.data.append(item)
        if self.data.count > 1{
            self.heapifyUp()
        }
    }
    
    func heapifyUp(){
        var currentIndex = self.data.count - 1
        while self.hasParent(currentIndex) && self.parent(currentIndex) > self.data[currentIndex]{
            self.data.swapAt(currentIndex, self.parentIndex(currentIndex))
            currentIndex = self.parentIndex(currentIndex)
        }
    }
    
    func heapifyDown(){
        var currentIndex = 0
        while self.hasLeftChild(currentIndex){
            var smallerChildIndex = self.leftChildIndex(currentIndex)
            if self.hasRightChild(currentIndex) 
                && self.rightChild(currentIndex) < self.leftChild(currentIndex){
                smallerChildIndex = self.rightChildIndex(currentIndex)
            }
            if self.data[currentIndex] > self.data[smallerChildIndex]{
                self.data.swapAt(currentIndex, smallerChildIndex)
                currentIndex = smallerChildIndex
            }else{
                break
            }
        }
    }
    
    var count:Int{
        return self.data.count
    }
}

---

Runtime: 208 ms

Memory Usage: 20.1 MB

class KthLargest {
    var q: Heap
    var k:Int = 0

    init(_ k: Int, _ nums: [Int]) {
        self.k = k
        q = Heap(sort: <)   
        for n in nums
        {
            add(n)
        } 
    }
    
    func add(_ val: Int) -> Int {
        if q.count < k
        {
            q.push(val)
        }
        else if (q.peek() != nil && q.peek()! < val)
        {
            q.pop()
            q.push(val)            
        }
        return q.peek()!
    }
}

public struct Heap {    
    var elements: [Int] = []
    let sort: (Int, Int) -> Bool
    var isEmpty: Bool {
        return self.elements.isEmpty
    }
    
    var count: Int {
        return self.elements.count
    }
    
    func peek() -> Int? {
        return elements.first
    }
    
    init(sort: @escaping (Int, Int) -> Bool, elements: [Int] = []) {
        self.sort = sort
        self.elements = elements
        
        if !elements.isEmpty {
            for i in stride(from: elements.count/2 - 1, through: 0, by: -1) {
                siftDown(from: i)
            }
        }
    }
    
    mutating func siftDown(from index: Int) {
        var parent = index
        while true {
            let left = leftIndex(of: parent)
            let right = rightIndex(of: parent)
            var candidate = parent
            if left < count && sort(elements[left], elements[candidate]) {
                candidate = left
            }
            if right < count && sort(elements[right], elements[candidate]) {
                candidate = right
            }
            if candidate == parent {
                return
            }
            elements.swapAt(parent, candidate)
            parent = candidate
        }
    }
    
    mutating func siftUp(from index: Int) {
        var child = index
        var parent = parentIndex(of: child)
        while child > 0 && sort(elements[child], elements[parent]) {
            elements.swapAt(child, parent)
            child = parent
            parent = parentIndex(of: child)
        }
    }
    
    mutating func push(_ element: Int) {
        elements.append(element)
        siftUp(from: count-1)
    }
    
    mutating func pop() -> Int? {
        guard !isEmpty else { return nil }
        elements.swapAt(0, count-1)
        defer {
            siftDown(from: 0)
        }
        return elements.popLast()
    }
    
    func leftIndex(of index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightIndex(of index: Int) -> Int {
        return (2 * index) + 2
    }
    
    func parentIndex(of index: Int) -> Int {
        return (index - 1) / 2
    }
}

---

224ms

class KthLargest {
    let minHeap: Heap<Int>
    let k: Int
    
    init(_ k: Int, _ nums: [Int]) {
        minHeap = Heap(elements: nums)    
        self.k = k
        
        while minHeap.count > k {
            minHeap.extract()
        }
    }
    
    func add(_ val: Int) -> Int {
        if minHeap.count < k || val > minHeap.peek()! {
            minHeap.insert(val)
        }
        
        if minHeap.count > k {
            minHeap.extract()
        }
        return minHeap.peek()!
    }
}


public class Heap<T: Comparable> {
    private var elements: [T] = []
    private let areInIncreasingOrder: (T, T) -> Bool

    public var count: Int {
        return elements.count
    }

    public var isEmpty: Bool {
        return elements.isEmpty
    }

    public init(elements: [T] = [], compareWith: @escaping ((T, T) -> Bool) = { $0 < $1 }) {
        self.elements = elements
        self.areInIncreasingOrder = compareWith

        let firstLeafIndex = elements.count / 2
        let lastParentIndex = firstLeafIndex - 1
        // Only need to bubble down non-leaf nodes (lastParentIndex to 0)
        for i in stride(from: lastParentIndex, through: 0, by: -1) {
            siftDown(from: i)
        }
    }

    public func insert(_ value: T) {
        elements.append(value)
        siftUp(from: elements.count - 1)
    }

    public func peek() -> T? {
        return elements.first
    }

    public func extract() -> T? {
        guard !elements.isEmpty else { return nil }
        let max = elements.first!
        elements.swapAt(0, elements.count - 1)
        elements.removeLast()
        siftDown(from: 0)
        return max
    }

    public func contains(_ element: T) -> Bool {
        return firstIndex(of: element, startingAt: 0) != nil
    }

    public func remove(_ element: T) -> T? {
        guard let indexOfElement = firstIndex(of: element) else { return nil }

        let lastIndex = elements.count - 1
        if indexOfElement == lastIndex {
            return elements.removeLast()
        } else {
            elements.swapAt(indexOfElement, lastIndex)
            let element = elements.removeLast()

            // May need to either move up or down
            siftUp(from: indexOfElement)
            siftDown(from: indexOfElement)

            return element
        }
    }

    // MARK: - Privates

    private func leftChildIndex(for parentIndex: Int) -> Int {
        return (2 * parentIndex) + 1
    }

    private func rightChildIndex(for parentIndex: Int) -> Int {
        return (2 * parentIndex) + 2
    }

    private func parentIndex(for childIndex: Int) -> Int {
        return (childIndex - 1) / 2
    }

    private func firstIndex(of element: T, startingAt startIndex: Int = 0) -> Int? {
        guard startIndex < count else { return nil }

        if element == elements[startIndex] {
            return startIndex
        } else if element > elements[startIndex] {
            return nil // can't be in heap
        } else if let foundIndex = firstIndex(of: element, startingAt: leftChildIndex(for: startIndex)) {
            return foundIndex // need to check both left and right children
        } else if let foundIndex = firstIndex(of: element, startingAt: rightChildIndex(for: startIndex)) {
            return foundIndex // need to check both left and right children
        }

        return nil // element was smaller than any element in the heap
    }

    private func siftUp(from childIndex: Int) {
        let child = elements[childIndex]
        let parentIndex = self.parentIndex(for: childIndex)
        let parent = elements[parentIndex]

        if areInIncreasingOrder(child, parent) {
            elements.swapAt(parentIndex, childIndex)
            siftUp(from: parentIndex)
        }
    }

    private func siftDown(from parentIndex: Int) {
        var maxElementIndex = parentIndex

        let leftChildIndex = self.leftChildIndex(for: parentIndex)
        if leftChildIndex < elements.count && areInIncreasingOrder(elements[leftChildIndex], elements[maxElementIndex]) {
            maxElementIndex = leftChildIndex
        }

        let rightChildIndex = self.rightChildIndex(for: parentIndex)
        if rightChildIndex < elements.count && areInIncreasingOrder(elements[rightChildIndex], elements[maxElementIndex]) {
            maxElementIndex = rightChildIndex
        }

        if parentIndex == maxElementIndex {
            return // base case
        } else {
            elements.swapAt(parentIndex, maxElementIndex)
            siftDown(from: maxElementIndex)
        }
    }
}

---

232ms

class KthLargest {
    
    var nums:[Int]
    var k:Int
    
    init(_ k: Int, _ nums: [Int]) {
        self.k = k
        self.nums = nums.sorted()
    }
    //[-1, 5]
    func add(_ val: Int) -> Int {
        var left = 0
        var right = nums.count - 1
        // [2,4,5,8]
        while left <= right {
            var mid = (left + right + 1) / 2
            if nums[mid] == val {
                left = mid
                right = mid - 1
            } else if nums[mid] > val {
                right = mid - 1
            } else {
                left = mid + 1
            }
        }
        
        nums.insert(val, at: left)
        return nums[nums.count - k]
    }
}

---

244ms

class KthLargest {
    
    let maxHeap: Heap
    let minHeap: Heap
    let k: Int
    
    init(_ k: Int, _ nums: [Int]) {
        self.maxHeap = Heap(type: .max, array: nums)
        self.minHeap = Heap(type: .min)
        self.k = k
    }
    
    func add(_ val: Int) -> Int {
        if minHeap.count == k {
            if let top = minHeap.peek() {
                if top < val {
                    minHeap.insert(val)
                    _ = minHeap.pop()
                    return minHeap.peek()!
                } else {
                    return top
                }
            }
        } else {
            maxHeap.insert(val)
            while minHeap.count < k {
                let val = maxHeap.pop()!
                minHeap.insert(val)
            }
            
            return minHeap.peek()!
        }
        
        return 0
    }
}

extension KthLargest {
    class Heap {
    
    // MARK: - HeapType
    enum HeapType {
        case min
        case max
        
        func compare(_ a: Int, _ b: Int) -> Bool {
            switch self {
            case .min:
                return a < b
            case .max:
                return a > b
            }
        }
    }
    
    // MARK: - Properties & Init
    var heap: [Int]
    var type: HeapType
    
    init(type: HeapType, array: [Int] = []) {
        self.type = type
        self.heap = array
        
        guard !array.isEmpty else { return }
        
        var i = (heap.count - 1) / 2
        while i >= 0 {
            heapify(i)
            i -= 1
        }
    }
    
    // MARK: - APIs
    
    var count: Int {
        return heap.count
    }
    
    // O[1]
    func pop() -> Int? {
        guard let first = heap.first else {
            return nil
        }
        
        if let last = heap.last {
            heap[0] = last
            heapify(0)
        }
        
        heap.removeLast()
        
        return first
    }
    
    // O[1]
    func peek() -> Int? {
        return heap.first
    }
    
    // O[log(n)]
    func insert(_ val: Int) {
        heap.append(val)
        siftUp(heap.count - 1)
    }
    
    // MARK: - Utilty Methods
    private func heapify(_ i: Int) {
        var top = i
        
        if let left = left(i), type.compare(heap[left], heap[top]) {
            top = left
        }
        
        if let right = right(i), type.compare(heap[right], heap[top]) {
            top = right
        }
        
        if top != i {
            heap.swapAt(i, top)
            heapify(top)
        }
    }
    
    private func siftUp(_ i: Int) {
        var parent = parentIndex(i)
        var this = i
        
        while let p = parent, type.compare(heap[this], heap[p]) {
            heap.swapAt(p, this)
            parent = parentIndex(p)
            this = p
        }
    }
    
    private func parentIndex(_ i: Int) -> Int? {
        guard i > 0 else { return nil }
        return (i - 1) / 2
    }
    
    private func left(_ i: Int) -> Int? {
        let left = i * 2 + 1
        return left < heap.count ? left : nil
    }
    
    private func right(_ i: Int) -> Int? {
        let right = i * 2 + 2
        return right < heap.count ? right : nil
    }
  }
}

---

252ms

class KthLargest {
    
    var minHeap: Heap<Int>
    var K: Int
    init(_ k: Int, _ nums: [Int]) {
        minHeap = Heap<Int>(sort: <, elements: nums)
        while minHeap.count > k {
            minHeap.remove()
        }
        K = k
    }
    
    func add(_ val: Int) -> Int {
        if minHeap.count < K {
            
            minHeap.insert(val) 
        } else if minHeap.peek()! < val {
            minHeap.remove()
            minHeap.insert(val)
        }
        return minHeap.peek()!
    }
}


/**
 * Your KthLargest object will be instantiated and called as such:
 * let obj = KthLargest(k, nums)
 * let ret_1: Int = obj.add(val)
 */
 
struct Heap<Element: Equatable> {
    var elements: [Element] = []
    let sort: (Element, Element) -> Bool
    init(sort: @escaping (Element, Element) -> Bool,
         elements: [Element] = []) {   // ?? Escaping?? Why
        self.sort = sort
        self.elements = elements
        
        if !elements.isEmpty {
            for i in stride(from: elements.count / 2 - 1, through: 0, by: -1) {
                siftDown(from: i)
            }
        }
    }
    
    var isEmpty: Bool {
        return elements.isEmpty
    }
    
    var count: Int {
        return elements.count
    }
    
    func peek() -> Element? {
        return elements.first
    }
    
    func leftChildIndex(ofParentAt index: Int) -> Int {
        return (2 * index) + 1
    }
    
    func rightChildIndex(ofParentAt index: Int) -> Int {
        return 2 * (index + 1)
    }
    
    func parentIndex(ofChildAt index: Int) -> Int {
        return (index - 1) / 2
    }
    
    mutating func siftDown(from index: Int) {
        var parent = index
        while true {
            let left = leftChildIndex(ofParentAt: parent)
            let right = rightChildIndex(ofParentAt: parent)
            var candidate = parent
            if left < count && sort(elements[left], elements[candidate]) {
                candidate = left
            }
            if right < count && sort(elements[right], elements[candidate]) {
                candidate = right
            }
            if candidate == parent {
                return
            }
            elements.swapAt(parent, candidate)
            parent = candidate
        }
    }
    
    mutating func siftUp(from index: Int) {
        var child = index
        var parent = parentIndex(ofChildAt: child)
        while child > 0 && sort(elements[child], elements[parent]) {
            elements.swapAt(child, parent)
            child = parent
            parent = parentIndex(ofChildAt: child)
        }
    }
    
    // Remove
    // Swap -> Sift Down( compare with two children)
    mutating func remove() -> Element? {
        guard !isEmpty else {
            return nil
        }
        elements.swapAt(0, count - 1)
        defer {
            siftDown(from: 0)
        }
        return elements.removeLast()
    }
    
    // Insert
    // Append -> sift(guolv) up
    mutating func insert(_ element: Element) {
        elements.append(element)
        siftUp(from: elements.count - 1)
    }
    
    func index(of element: Element, startingAt i: Int) -> Int? {
        if i >= count {
            return nil
        }
        if sort(element, elements[i]) {
            return nil
        }
        if element == elements[i] {
            return i
        }
        if let j = index(of: element, startingAt: leftChildIndex(ofParentAt: i)) {
            return j
        }
        if let j = index(of: element, startingAt: rightChildIndex(ofParentAt: i)) {
            return j
        }
        return nil
    }
}

---

256ms

class KthLargest {
    
    let maxHeap: Heap
    let minHeap: Heap
    let k: Int
    
    init(_ k: Int, _ nums: [Int]) {
        self.maxHeap = Heap(type: .max, array: nums)
        self.minHeap = Heap(type: .min)
        self.k = k
    }
    
    func add(_ val: Int) -> Int {
        if minHeap.count == k {
            if let top = minHeap.peek() {
                if top < val {
                    minHeap.insert(val)
                    _ = minHeap.pop()
                    return minHeap.peek()!
                } else {
                    return top
                }
            }
        } else {
            maxHeap.insert(val)
            while minHeap.count < k {
                let val = maxHeap.pop()!
                minHeap.insert(val)
            }
            
            return minHeap.peek()!
        }
        
        return 0
    }
}

extension KthLargest {
    class Heap {
    
    // MARK: - HeapType
    enum HeapType {
        case min
        case max
        
        func compare(_ a: Int, _ b: Int) -> Bool {
            switch self {
            case .min:
                return a < b
            case .max:
                return a > b
            }
        }
    }
    
    // MARK: - Properties & Init
    var heap: [Int]
    var type: HeapType
    
    init(type: HeapType, array: [Int] = []) {
        self.type = type
        self.heap = array
        
        guard !array.isEmpty else { return }
        
        var i = (heap.count - 1) / 2
        while i >= 0 {
            heapify(i)
            i -= 1
        }
    }
    
    // MARK: - APIs
    
    var count: Int {
        return heap.count
    }
    
    // O[1]
    func pop() -> Int? {
        guard let first = heap.first else {
            return nil
        }
        
        if let last = heap.last {
            heap[0] = last
            heapify(0)
        }
        
        heap.removeLast()
        
        return first
    }
    
    // O[1]
    func peek() -> Int? {
        return heap.first
    }
    
    // O[log(n)]
    func insert(_ val: Int) {
        heap.append(val)
        siftUp(heap.count - 1)
    }
    
    // MARK: - Utilty Methods
    private func heapify(_ i: Int) {
        var top = i
        
        if let left = left(i), type.compare(heap[left], heap[top]) {
            top = left
        }
        
        if let right = right(i), type.compare(heap[right], heap[top]) {
            top = right
        }
        
        if top != i {
            heap.swapAt(i, top)
            heapify(top)
        }
    }
    
    private func siftUp(_ i: Int) {
        var parent = parentIndex(i)
        var this = i
        
        while let p = parent, type.compare(heap[this], heap[p]) {
            heap.swapAt(p, this)
            parent = parentIndex(p)
            this = p
        }
    }
    
    private func parentIndex(_ i: Int) -> Int? {
        guard i > 0 else { return nil }
        return (i - 1) / 2
    }
    
    private func left(_ i: Int) -> Int? {
        let left = i * 2 + 1
        return left < heap.count ? left : nil
    }
    
    private func right(_ i: Int) -> Int? {
        let right = i * 2 + 2
        return right < heap.count ? right : nil
    }
 }
}

---

344ms

class KthLargest {
    private let k: Int
    private var count: Int
    private var minHeap: MinHeap<Int>

    init(_ k: Int, _ nums: [Int]) {
        self.k = k
        self.count = 0
        self.minHeap = MinHeap<Int>()
        for num in nums {
            add(num)
        }
    }

    @discardableResult
    func add(_ value: Int) -> Int {
        count += 1

        if count <= k {
            minHeap.insert(value)
            return minHeap.min()!
        }

        if value >= minHeap.min()! {
            minHeap.delete()
            minHeap.insert(value)
        }

        return minHeap.min()!
    }
}

/**
 * Your KthLargest object will be instantiated and called as such:
 * let obj = KthLargest(k, nums)
 * let ret_1: Int = obj.add(val)
 */
 
public class Heap<ValueType: Comparable> {

    public private(set) var values: [ValueType]
    private let debug: Bool

    public init(debug: Bool = false) {
        values = []
        self.debug = debug
    }

    public var count: Int {
        return values.count
    }

    public var isEmpty: Bool {
        return values.count <= 0
    }

    private var rootNodeIndex: Int {
        return 0
    }

    private var lastNodeIndex: Int {
        return values.count - 1
    }

    private func log(_ string: String) {
        guard debug else {
            return
        }

        print(string)
    }

    func order(parentNodeValue: ValueType, childNodeValue: ValueType) -> Bool {
        return parentNodeValue < childNodeValue
    }

    private func order(parentNodeIndex: Int, childNodeIndex: Int) -> Bool {
        guard childNodeIndex >= rootNodeIndex && childNodeIndex <= lastNodeIndex else {
            return true
        }

        guard parentNodeIndex >= rootNodeIndex && parentNodeIndex <= lastNodeIndex else {
            return true
        }

        return order(parentNodeValue: values[parentNodeIndex], childNodeValue: values[childNodeIndex])
    }

    // O(log(n)) time
    public func insert(_ value: ValueType) {
        values.append(value)
        siftUp()
        log("[insert] value: (value)")
    }

    // O(log(n)) time
    @discardableResult
    public func delete() -> ValueType? {
        guard !isEmpty else {
            return nil
        }

        let rootValue = values[rootNodeIndex]
        swapValuesAt(index1: rootNodeIndex, index2: lastNodeIndex)
        values.remove(at: lastNodeIndex)
        siftDown()

        log("[delete] value: (rootValue)")
        return rootValue
    }

    // Constant time
    public func rootValue() -> ValueType? {
        guard !isEmpty else {
            return nil
        }

        return values[rootNodeIndex]
    }

    // MARK: Private methods

    // Sift down the root node to the correct position until the heap properties are satisfied
    private func siftDown() {
        guard !isEmpty else {
            return
        }

        var currentNodeIndex = rootNodeIndex
        while currentNodeIndex <= lastNodeIndex {
            let leftNodeIndex = left(of: currentNodeIndex)
            let rightNodeIndex = right(of: currentNodeIndex)

            if order(parentNodeIndex: currentNodeIndex, childNodeIndex: leftNodeIndex)
                && order(parentNodeIndex: currentNodeIndex, childNodeIndex: rightNodeIndex) {
                    // current node is at the correct position
                    break
            } else if order(parentNodeIndex: leftNodeIndex, childNodeIndex: currentNodeIndex)
                && order(parentNodeIndex: leftNodeIndex, childNodeIndex: rightNodeIndex) {
                    // current node has to swapped with the left node
                    swapValuesAt(index1: currentNodeIndex, index2: leftNodeIndex)
                    currentNodeIndex = leftNodeIndex
            } else if order(parentNodeIndex: rightNodeIndex, childNodeIndex: currentNodeIndex)
                && order(parentNodeIndex: rightNodeIndex, childNodeIndex: leftNodeIndex) {
                    // current node has to swapped with the right node
                    swapValuesAt(index1: currentNodeIndex, index2: rightNodeIndex)
                    currentNodeIndex = rightNodeIndex
            } else {
                    break
            }
        }
    }

    // Sift up the last node to the correct position until the heap properties are satisfied
    private func siftUp() {
        guard !isEmpty else {
            return
        }

        var currentNodeIndex = lastNodeIndex
        while currentNodeIndex > rootNodeIndex {
            let parentNodeIndex = parent(of: currentNodeIndex)
            if order(parentNodeValue: values[parentNodeIndex], childNodeValue: values[currentNodeIndex]) {
                break
            } else {
                swapValuesAt(index1: currentNodeIndex, index2: parentNodeIndex)
                currentNodeIndex = parentNodeIndex
            }
        }
    }

    // MARK: Helper methods

    private func swapValuesAt(index1: Int, index2: Int) {
        guard !isEmpty && index1 < count && index2 < count else {
            return
        }

        let temp = values[index1]
        values[index1] = values[index2]
        values[index2] = temp
    }

    private func left(of index: Int) -> Int {
        return 2 * index + 1
    }

    private func right(of index: Int) -> Int {
        return 2 * index + 2
    }

    private func isValid(index: Int) -> Bool {
        return index >= 0 && index < values.count
    }

    private func parent(of index: Int) -> Int {
        return Int(ceil(Double(index)/2) - 1.0)
    }

    public func printValues() {
        log("Heap: (values)")
    }

}

public class MinHeap<ValueType: Comparable>: Heap<ValueType> {

    public override init(debug: Bool = false) {
        super.init(debug: debug)
    }

    override func order(parentNodeValue: ValueType, childNodeValue: ValueType) -> Bool {
        return parentNodeValue <= childNodeValue
    }

    public func min() -> ValueType? {
        return rootValue()
    }
}

public class MaxHeap<ValueType: Comparable>: Heap<ValueType> {

    public override init(debug: Bool = false) {
        super.init(debug: debug)
    }

    override func order(parentNodeValue: ValueType, childNodeValue: ValueType) -> Bool {
        return parentNodeValue >= childNodeValue
    }

    public func max() -> ValueType? {
        return rootValue()
    }
}

---

1076ms

class KthLargest {
    var list:[Int] = [Int]()
    var kth:Int = 0
    init(_ k: Int, _ nums: [Int]) {
        var nums = nums
        nums.sort(by: >)
        for num in nums {
            if list.count <= k {
            list.append(num)
            }
        }
        kth = k
    }
    
    func add(_ val: Int) -> Int {
        if list.count == 0 {
            list.append(val)
        } else {
         if val > list.last! {
        for i in 0 ..< list.count {
            var temp = list[i] 
            if val >= temp {
              list.insert(val, at: i)
                break;
        }
     }
        }else {
           if list.count < kth {
          list.append(val)
       }     
         }
      if list.count > kth {
          list.removeLast()
       }   
        }
      return list[kth-1]
    } 
}

---

1408ms

class KthLargest {
    
    fileprivate var array :[Int]
    fileprivate var k :Int
    
    init(_ k: Int, _ nums: [Int]) {
        array = nums
        self.k = k
        
        if array.count >= k {
            array.sort(by: >)
            array = Array(array[0...k-1])
        }
        
    }
    
    func add(_ val: Int) -> Int {
        
        if array.count < k-1 {
            
            array.append(val)
            return 0
            
        }else if array.count == k-1{
            
            array.append(val)
            array = array.sorted(by: >)
    
            return array[k-1]
        }
        
        if val >= array[0] {
            
            array.insert(val, at: 0)
            array.removeLast()
            
        }else if val < array[k-1] {
            // 空
        }else {
            
            for i in 0...k-1 {
                if array[i] <= val {
                    array.insert(val, at: i)
                    array.removeLast()
                    break
                }
            }
        }
        
        return array[k-1]
    }
}