Create Solution.swift

Author: yanglbme

solution/0200-0299/0295.Find Median from Data Stream/Solution.swift

@@ -0,0 +1,111 @@
+class MedianFinder {
+    private var minQ = Heap<Int>(sort: <)
+    private var maxQ = Heap<Int>(sort: >)
+
+    init() {
+    }
+
+    func addNum(_ num: Int) {
+        maxQ.insert(num)
+        minQ.insert(maxQ.remove()!)
+        if maxQ.count < minQ.count {
+            maxQ.insert(minQ.remove()!)
+        }
+    }
+
+    func findMedian() -> Double {
+        if maxQ.count > minQ.count {
+            return Double(maxQ.peek()!)
+        }
+        return (Double(maxQ.peek()!) + Double(minQ.peek()!)) / 2.0
+    }
+}
+
+struct Heap<T> {
+    var elements: [T]
+    let sort: (T, T) -> Bool
+
+    init(sort: @escaping (T, T) -> Bool, elements: [T] = []) {
+        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() -> T? {
+        return elements.first
+    }
+
+    mutating func insert(_ value: T) {
+        elements.append(value)
+        siftUp(from: elements.count - 1)
+    }
+
+    mutating func remove() -> T? {
+        guard !elements.isEmpty else { return nil }
+        elements.swapAt(0, elements.count - 1)
+        let removedValue = elements.removeLast()
+        siftDown(from: 0)
+        return removedValue
+    }
+
+    private 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)
+        }
+    }
+
+    private 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
+        }
+    }
+
+    private func parentIndex(ofChildAt index: Int) -> Int {
+        return (index - 1) / 2
+    }
+
+    private func leftChildIndex(ofParentAt index: Int) -> Int {
+        return 2 * index + 1
+    }
+
+    private func rightChildIndex(ofParentAt index: Int) -> Int {
+        return 2 * index + 2
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * let obj = MedianFinder()
+ * obj.addNum(num)
+ * let ret_2: Double = obj.findMedian()
+ */