Merge pull request neetcode-gh#1441 from Mahim1997/dev/1985_Java_Swift

1985. Find the Kth Largest Integer in the Array

Author: Ahmad-A0

java/1985-Find-The-Kth-Largest-Integer-In-The-Array.java

@@ -0,0 +1,32 @@
+// Min Heap comparator for reverse priority queue
+class StringNumberComparartor implements Comparator<String> {
+    @Override
+    public int compare(String s1, String s2) {
+        if(s1.length() != s2.length()) {
+            return (s1.length() - s2.length());
+        }
+        int len = s1.length();
+        for(int i=0; i<len; i++) {
+            char c1 = s1.charAt(i), c2 = s2.charAt(i);
+            if(c1 == c2) { continue; }
+            return (c1 - c2);
+        }
+        return 0;
+    }
+}
+
+class Solution {
+    public String kthLargestNumber(String[] nums, int k) {
+        // Reverse pq to store only k elements [i.e. Min Heap]
+        PriorityQueue<String> pq = new PriorityQueue<>(new StringNumberComparartor());
+
+        for(String numStr: nums) {
+            pq.add(numStr);
+            if(pq.size() > k) {
+                pq.remove();
+            }
+        }
+
+        return pq.peek();
+    }
+}

swift/1985-Find-The-Kth-Largest-Integer-In-The-Array.swift

@@ -0,0 +1,143 @@
+class Solution {
+    func kthLargestNumber(_ nums: [String], _ k: Int) -> String {
+        // Use a Min Heap for storing upto k-elements max in the priority queue
+        var heap: Heap<String> = Heap(sort: { (str1, str2) in
+            guard str1.count == str2.count else { return str1.count < str2.count }
+            for (c1, c2) in zip(str1, str2) {
+                guard c1 == c2 else { return c1 < c2 }
+            }
+            return false
+        })
+
+        nums.forEach { num in
+            heap.insert(num)
+            if heap.count > k {
+                heap.remove()
+            }
+        }
+
+        return heap.peek() ?? ""
+    }
+}
+
+// Heap used from https://github.com/kodecocodes/swift-algorithm-club/blob/master/Heap/Heap.swift
+public struct Heap<T> {
+    var nodes = [T]()
+
+    private var orderCriteria: (T, T) -> Bool
+
+    public init(sort: @escaping (T, T) -> Bool) {
+        self.orderCriteria = sort
+    }
+
+    public init(array: [T], sort: @escaping (T, T) -> Bool) {
+        self.orderCriteria = sort
+        configureHeap(from: array)
+    }
+
+    private mutating func configureHeap(from array: [T]) {
+        nodes = array
+        for i in stride(from: (nodes.count/2-1), through: 0, by: -1) {
+            shiftDown(i)
+        }
+    }
+
+    public var isEmpty: Bool {
+        return nodes.isEmpty
+    }
+
+    public var count: Int {
+        return nodes.count
+    }
+
+    @inline(__always) internal func parentIndex(ofIndex i: Int) -> Int {
+        return (i - 1) / 2
+    }
+
+    @inline(__always) internal func leftChildIndex(ofIndex i: Int) -> Int {
+        return 2*i + 1
+    }
+
+    @inline(__always) internal func rightChildIndex(ofIndex i: Int) -> Int {
+        return 2*i + 2
+    }
+
+    public func peek() -> T? {
+        return nodes.first
+    }
+
+    public mutating func insert(_ value: T) {
+        nodes.append(value)
+        shiftUp(nodes.count - 1)
+    }
+
+    public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
+        for value in sequence {
+            insert(value)
+        }
+    }
+
+    public mutating func replace(index i: Int, value: T) {
+        guard i < nodes.count else { return }
+        remove(at: i)
+        insert(value)
+    }
+
+    @discardableResult public mutating func remove() -> T? {
+        guard !nodes.isEmpty else { return nil }
+        if nodes.count == 1 {
+            return nodes.removeLast()
+        } else {
+            let value = nodes[0]
+            nodes[0] = nodes.removeLast()
+            shiftDown(0)
+            return value
+        }
+    }
+
+    @discardableResult public mutating func remove(at index: Int) -> T? {
+        guard index < nodes.count else { return nil }
+        let size = nodes.count - 1
+        if index != size {
+            nodes.swapAt(index, size)
+            shiftDown(from: index, until: size)
+            shiftUp(index)
+        }
+        return nodes.removeLast()
+    }
+
+    internal mutating func shiftUp(_ index: Int) {
+        var childIndex = index
+        let child = nodes[childIndex]
+        var parentIndex = self.parentIndex(ofIndex: childIndex)
+
+        while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
+            nodes[childIndex] = nodes[parentIndex]
+            childIndex = parentIndex
+            parentIndex = self.parentIndex(ofIndex: childIndex)
+        }
+
+        nodes[childIndex] = child
+    }
+
+    internal mutating func shiftDown(from index: Int, until endIndex: Int) {
+        let leftChildIndex = self.leftChildIndex(ofIndex: index)
+        let rightChildIndex = leftChildIndex + 1
+
+        var first = index
+        if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
+            first = leftChildIndex
+        }
+        if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
+            first = rightChildIndex
+        }
+        if first == index { return }
+
+        nodes.swapAt(index, first)
+        shiftDown(from: first, until: endIndex)
+    }
+
+    internal mutating func shiftDown(_ index: Int) {
+        shiftDown(from: index, until: nodes.count)
+    }
+}