feat: add swift implementation to lcci problem: No.17.20

lcci/17.20.Continuous Median/README.md

@@ -189,6 +189,114 @@ func (h *hp) Pop() any {
 }
 ```
 
+```swift
+class MedianFinder {
+    private var minHeap = Heap<Int>(sort: <)
+    private var maxHeap = Heap<Int>(sort: >)
+
+    init() {
+    }
+
+    func addNum(_ num: Int) {
+        maxHeap.insert(num)
+        minHeap.insert(maxHeap.remove()!)
+
+        if maxHeap.count < minHeap.count {
+            maxHeap.insert(minHeap.remove()!)
+        }
+    }
+
+    func findMedian() -> Double {
+        if maxHeap.count > minHeap.count {
+            return Double(maxHeap.peek()!)
+        }
+        return (Double(maxHeap.peek()!) + Double(minHeap.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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

lcci/17.20.Continuous Median/README_EN.md

@@ -185,6 +185,114 @@ func (h *hp) Pop() any {
 }
 ```
 
+```swift
+class MedianFinder {
+    private var minHeap = Heap<Int>(sort: <)
+    private var maxHeap = Heap<Int>(sort: >)
+
+    init() {
+    }
+
+    func addNum(_ num: Int) {
+        maxHeap.insert(num)
+        minHeap.insert(maxHeap.remove()!)
+
+        if maxHeap.count < minHeap.count {
+            maxHeap.insert(minHeap.remove()!)
+        }
+    }
+
+    func findMedian() -> Double {
+        if maxHeap.count > minHeap.count {
+            return Double(maxHeap.peek()!)
+        }
+        return (Double(maxHeap.peek()!) + Double(minHeap.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
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

lcci/17.20.Continuous Median/Solution.swift

@@ -0,0 +1,105 @@
+class MedianFinder {
+    private var minHeap = Heap<Int>(sort: <)
+    private var maxHeap = Heap<Int>(sort: >)
+
+    init() {
+    }
+
+    func addNum(_ num: Int) {
+        maxHeap.insert(num)
+        minHeap.insert(maxHeap.remove()!)
+
+        if maxHeap.count < minHeap.count {
+            maxHeap.insert(minHeap.remove()!)
+        }
+    }
+
+    func findMedian() -> Double {
+        if maxHeap.count > minHeap.count {
+            return Double(maxHeap.peek()!)
+        }
+        return (Double(maxHeap.peek()!) + Double(minHeap.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
+    }
+}