432_All_O_one_Data_Structure

Author: Partho Biswas

README.md

@@ -290,6 +290,7 @@ I have solved quite a number of problems from several topics. See the below tabl
 |25| **[460. LFU Cache](https://tinyurl.com/y7qokgr8)** | [Python](https://tinyurl.com/wu6rdaw/237_Delete_Node_in_a_Linked_List.py)| [Art 1](https://tinyurl.com/rtnhhys) | Easy |  |
 |26| **[708. Insert into a Sorted Circular Linked List](https://tinyurl.com/yy5ga9gn)** | [Python](https://tinyurl.com/wu6rdaw/708_Insert_into_a_Sorted_Circular_Linked_List.py), [Swift](https://tinyurl.com/wuja3c4/708_Insert_into_a_Sorted_Circular_Linked_List.swift) | [Art 1](https://tinyurl.com/y4p9krj8) | Medium |  |
 |27| **[203. Remove Linked List Elements](https://tinyurl.com/y6bmycyr)** | [Python](https://tinyurl.com/wu6rdaw/203_Remove_Linked_List_Elements.py), [Swift](https://tinyurl.com/wuja3c4/203_Remove_Linked_List_Elements.swift) | --- | Easy |  |
+|28| **[432. All O`one Data Structure](https://tinyurl.com/zqkzen4)** | [Python](https://tinyurl.com/wu6rdaw/432_All_O_one_Data_Structure.py), [Swift](https://tinyurl.com/wuja3c4/432_All_O_one_Data_Structure.swift) | [Art 1](https://tinyurl.com/y2ame7dc) | Hard | Super hard and super important |
 
 
 </p>

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/432_All_O_one_Data_Structure.swift

@@ -0,0 +1,105 @@
+import Foundation
+// Source: https://tinyurl.com/y2ame7dc
+public class DoublyLinkedListNode {
+    public var counterValKeySet = Set<String>()
+    public var next: DoublyLinkedListNode?
+    public var prev: DoublyLinkedListNode?
+}
+
+public class DoublyLinkedList {
+    public var dummyHead = DoublyLinkedListNode()
+    public var dummyTail = DoublyLinkedListNode()
+    public init() {
+        dummyHead.next = dummyTail
+        dummyTail.prev = dummyHead
+    }
+    
+    public func insertAfter(_ node: DoublyLinkedListNode) -> DoublyLinkedListNode {
+        var (nodeToReturn, tempNode) = (DoublyLinkedListNode(), node.next)
+        node.next = nodeToReturn
+        nodeToReturn.prev = node
+        nodeToReturn.next = tempNode
+        tempNode?.prev = nodeToReturn
+        return nodeToReturn
+    }
+    
+    public func insertBefore(_ node: DoublyLinkedListNode) -> DoublyLinkedListNode {
+        return insertAfter(node.prev!)
+    }
+    
+    public func removeNode(_ node: DoublyLinkedListNode) {
+        node.prev?.next = node.next
+        node.next?.prev = node.prev
+    }
+}
+
+class AllOne {
+    var keyCounterToNodeMap = [Int: DoublyLinkedListNode]()
+    var keyToCounterMap = [String: Int]()
+    var dll = DoublyLinkedList()
+    
+    /** Initialize your data structure here. */
+    init() {
+        keyCounterToNodeMap[0] = dll.dummyHead
+    }
+    
+    
+    private func removePreviousKeyAndNode(_ previousCount: Int, _ key: String) {
+        if var previousNode = keyCounterToNodeMap[previousCount] {
+            previousNode.counterValKeySet.remove(key)
+            if previousNode.counterValKeySet.isEmpty {
+                dll.removeNode(previousNode)
+                keyCounterToNodeMap.removeValue(forKey: previousCount)
+            }
+        }
+    }
+    
+    /** Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
+    func inc(_ key: String) {
+        keyToCounterMap[key, default:0] += 1
+        let (currentCount, previousCount) = (keyToCounterMap[key]!, keyToCounterMap[key]! - 1)
+        if keyCounterToNodeMap[currentCount] == nil {
+            keyCounterToNodeMap[currentCount] = dll.insertAfter(keyCounterToNodeMap[previousCount]!)
+        }
+        keyCounterToNodeMap[currentCount]?.counterValKeySet.insert(key)
+        if previousCount > 0 {
+            removePreviousKeyAndNode(previousCount, key)
+        }
+    }
+    
+    /** Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
+    func dec(_ key: String) {
+        if let previousCount = keyToCounterMap[key] {
+            keyToCounterMap[key] = previousCount - 1
+            if let currentCounter = keyToCounterMap[key] {
+                if currentCounter == 0 {
+                    keyToCounterMap.removeValue(forKey: key)
+                } else {
+                    if keyCounterToNodeMap[currentCounter] == nil {
+                        keyCounterToNodeMap[currentCounter] = dll.insertBefore(keyCounterToNodeMap[previousCount]!)
+                    }
+                    keyCounterToNodeMap[currentCounter]?.counterValKeySet.insert(key)
+                }
+            }
+            removePreviousKeyAndNode(previousCount, key)
+        }
+    }
+    
+    /** Returns one of the keys with maximal value. */
+    func getMaxKey() -> String {
+        if dll.dummyTail.prev!.counterValKeySet.count > 0 {
+            return dll.dummyTail.prev!.counterValKeySet.first ?? ""
+        } else {
+            return ""
+        }
+    }
+    
+    /** Returns one of the keys with Minimal value. */
+    func getMinKey() -> String {
+        if dll.dummyHead.next!.counterValKeySet.count > 0 {
+            return dll.dummyHead.next!.counterValKeySet.first ?? ""
+        } else {
+            return ""
+        }
+    }
+}