[Swift]LeetCode706. 设计哈希映射 | Design HashMap

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

Design a HashMap without using any built-in hash table libraries.

To be specific, your design should include these functions:

• put(key, value) : Insert a (key, value) pair into the HashMap. If the value already exists in the HashMap, update the value.
• get(key): Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.
• remove(key) : Remove the mapping for the value key if this map contains the mapping for the key.

Example:

MyHashMap hashMap = new MyHashMap();
hashMap.put(1, 1);          
hashMap.put(2, 2);         
hashMap.get(1);            // returns 1
hashMap.get(3);            // returns -1 (not found)
hashMap.put(2, 1);          // update the existing value
hashMap.get(2);            // returns 1 
hashMap.remove(2);          // remove the mapping for 2
hashMap.get(2);            // returns -1 (not found) 

Note:

• All keys and values will be in the range of [0, 1000000].
• The number of operations will be in the range of [1, 10000].
• Please do not use the built-in HashMap library.

---

不使用任何内建的哈希表库设计一个哈希映射

具体地说，你的设计应该包含以下的功能

• put(key, value)：向哈希映射中插入(键,值)的数值对。如果键对应的值已经存在，更新这个值。
• get(key)：返回给定的键所对应的值，如果映射中不包含这个键，返回-1。
• remove(key)：如果映射中存在这个键，删除这个数值对。

示例：

MyHashMap hashMap = new MyHashMap();
hashMap.put(1, 1);          
hashMap.put(2, 2);         
hashMap.get(1);            // 返回 1
hashMap.get(3);            // 返回 -1 (未找到)
hashMap.put(2, 1);         // 更新已有的值
hashMap.get(2);            // 返回 1 
hashMap.remove(2);         // 删除键为2的数据
hashMap.get(2);            // 返回 -1 (未找到) 

注意：

• 所有的值都在 [1, 1000000]的范围内。
• 操作的总数目在[1, 10000]范围内。
• 不要使用内建的哈希库。

---

 484ms

class MyHashMap {
    var arr: [Int]
    /** Initialize your data structure here. */
    init() {
        arr = []
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        if arr.count <= key {
            arr += Array(repeating: -1, count: key-arr.count + 1)
        }
        arr[key] = value
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        if key >= arr.count {return -1}
        return arr[key]
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        if key >= arr.count {return}
        arr[key] = -1
    }
}

/**
 * Your MyHashMap object will be instantiated and called as such:
 * let obj = MyHashMap()
 * obj.put(key, value)
 * let ret_2: Int = obj.get(key)
 * obj.remove(key)
 */

---

492ms

class MyHashMap {

    var array = Array(repeating: -1, count: 1000000)
    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
      array[key] = value
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
      return array[key]
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
      array[key] = -1
    }
}

---

496ms

class MyHashMap {

    /** Initialize your data structure here. */
    typealias Pair = (key: Int, value: Int)
    let MAX_LENGTH = 10000
    var array: [[Pair]?]
    
    init() {
        array = Array(repeating: nil, count: MAX_LENGTH)
    }
    
    private func getIndex(_ key: Int) -> Int {
        return key % MAX_LENGTH
    }
    
    private func getPos(_ key: Int, _ bucketIndex: Int) -> Int {
        if let bucket = array[bucketIndex] {
            for i in 0..<bucket.count {
                let pair = bucket[i]
                if pair.key == key {
                    return i
                }
            }
        }
        
        return -1
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        let index = getIndex(key)
        let pos = getPos(key, index)
        if array[index] != nil {
            if pos < 0 {
                // key not exisiting
                array[index]!.append((key,value))
            } else {
                // update key with new value
                array[index]![pos] = (key,value)
            }
        } else {
            // create a new bucket
            array[index] = [(key,value)]
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        let index = getIndex(key)
        let pos = getPos(key, index)
        if array[index] != nil && pos >= 0 {
            return array[index]![pos].value
        } 
        return -1
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        let index = getIndex(key)
        let pos = getPos(key, index) 
        if array[index] != nil && pos >= 0 {
            array[index]!.remove(at: pos)
        }
    }
}

---

Runtime: 500 ms

Memory Usage: 20.5 MB

class LinkedNode {
    var next: LinkedNode?
    var key: Int
    var val: Int
    
    init(_ key: Int, _ val: Int) {
        self.key = key
        self.val = val
    }
}

class MyHashMap {
    
    private var nodes: [LinkedNode?]

    /** Initialize your data structure here. */
    init() {
        nodes = Array(repeating: nil, count: 10000)
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        let index = hash(key)
        guard let node = nodes[index] else {
            nodes[index] = LinkedNode(key, value)
            return
        }
        
        var next: LinkedNode? = node
        var pre: LinkedNode? = nil
        while next != nil, next!.key != key {
            pre = next
            next = next?.next
        }
        
        if let next = next {
            next.val = value
        } else {
            pre?.next = LinkedNode(key, value)
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        let index = hash(key)
        guard let node = nodes[index] else {
            return -1
        }
        
        var next: LinkedNode? = node
        var pre: LinkedNode? = nil
        while next != nil, next!.key != key {
            pre = next
            next = next?.next
        }
        
        return next?.val ?? -1
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        let index = hash(key)
        guard let node = nodes[index] else {
            return
        }
        
        var next: LinkedNode? = node
        var pre: LinkedNode? = nil
        while next != nil, next!.key != key {
            pre = next
            next = next?.next
        }
        
        if let pre = pre {
            pre.next = next?.next
        } else {
            nodes[index] = next?.next
        }
    }
    
    private func hash(_ key: Int) -> Int {
        return key % 10000
    }
    
}

/**
 * Your MyHashMap object will be instantiated and called as such:
 * let obj = MyHashMap()
 * obj.put(key, value)
 * let ret_2: Int = obj.get(key)
 * obj.remove(key)
 */ 

---

516ms

class ListNode<T> {
    
    var value: T
    var next: ListNode<T>?
    
    init(value: T) {
        self.value = value
    }
}

struct KeyValue {
    var key: Int
    var value: Int
}

class MyHashMap {
    
    private var buckets = [ListNode<KeyValue>?](repeating: nil, count: 1000)

    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        if let existingNodes = findNode(key: key) {
            existingNodes.node.value.value = value
        } else {
            let hash = getHash(key)
            
            let value = KeyValue(key: key, value: value)
            let newNode = ListNode<KeyValue>(value: value)
            newNode.next = buckets[hash % buckets.count]
            buckets[hash % buckets.count] = newNode
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        guard let existingNodes = findNode(key: key) else {
            return -1
        }
        return existingNodes.node.value.value
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        guard let existingNodes = findNode(key: key) else {
            return 
        }
        
        if let previous = existingNodes.previous {
            previous.next = existingNodes.node.next
        } else {
            // the key is the head
            let hash = getHash(key)
            buckets[hash % buckets.count] = existingNodes.node.next
        }
    }
    
    private func findNode(key: Int) -> (previous: ListNode<KeyValue>?, node: ListNode<KeyValue>)? {
        let hash = getHash(key)
        
        var previous: ListNode<KeyValue>? = nil
        var head = buckets[hash % buckets.count]
        while let _head = head {
            if _head.value.key == key {
                return (previous,_head)
            }
            previous = head
            head = _head.next
        }
        
        return nil // didn't find this key in the bucket
    }
    
    private func getHash(_ key: Int) -> Int {
        return abs(key.hashValue)
    }
}

---

528ms

class MyHashMap {

    /** Initialize your data structure here. */
    typealias Pair = (key: Int, value: Int)
    let MAX_LENGTH = 10000
    var array: [[Pair]?]
    
    init() {
        array = Array(repeating: nil, count: MAX_LENGTH)
    }
    
    private func getIndex(_ key: Int) -> Int {
        return key % MAX_LENGTH
    }
    
    private func getPos(_ key: Int, _ bucketIndex: Int) -> Int {
        if let bucket = array[bucketIndex] {
            for i in 0..<bucket.count {
                let pair = bucket[i]
                if pair.key == key {
                    return i
                }
            }
        }
        
        return -1
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        let index = getIndex(key)
        let pos = getPos(key, index)
        if array[index] != nil {
            if pos < 0 {
                // key not exisiting
                array[index]!.append((key,value))
            } else {
                // update key with new value
                array[index]![pos] = (key,value)
            }
        } else {
            // create a new bucket
            array[index] = [(key,value)]
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        let index = getIndex(key)
        let pos = getPos(key, index)
        if array[index] != nil && pos >= 0 {
            return array[index]![pos].value
        } 
        return -1
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        let index = getIndex(key)
        let pos = getPos(key, index) 
        if array[index] != nil && pos >= 0 {
            array[index]!.remove(at: pos)
        }
    }
}

---

572ms

class ListNode<T> {
    var value: T
    var next: ListNode<T>?
    
    init(value: T) {
        self.value = value
    }
}

class HashMap<Key: Hashable, Value> {
    
    private struct Pair {
        var key: Key
        var value: Value
    }
    
    private var buckets = [ListNode<Pair>?](repeating: nil, count: 1000)

    func put(key: Key, value: Value) {
        
        let pair = Pair(key: key, value: value)
        
        if let existingNodes = find(key: key) {
            existingNodes.node.value = pair
        } else {
            
            let index = hash(from: key) % buckets.count
            
            let newNode = ListNode<Pair>(value: pair)
            newNode.next = buckets[index]
            buckets[index] = newNode
        }
    }
    
    func get(key: Key) -> Value? {
        return find(key: key)?.node.value.value
    }
    
    func remove(key: Key) {
        guard let nodes = find(key: key) else {
            return // couldn't find it
        }
        
        if let previousNode = nodes.previousNode {
            previousNode.next = nodes.node.next
        } else {
            let index = hash(from: key) % buckets.count
            buckets[index] = nodes.node.next
        }
    }
    
    private func find(key: Key) -> (previousNode: ListNode<Pair>?, node: ListNode<Pair>)? {
        let hashValue = hash(from: key)
        let index = hashValue % buckets.count
        
        var previousNode: ListNode<Pair>? = nil
        var currentNode: ListNode<Pair>? = buckets[index]
        
        while let _currentNode = currentNode {
            if _currentNode.value.key == key {
                return (previousNode, _currentNode)
            }
            
            previousNode = _currentNode
            currentNode = _currentNode.next
        }
        
        return nil
    }
    
    private func hash(from key: Key) -> Int {
        return abs(key.hashValue)
    }
}


class MyHashMap {
    
    private let hashMap = HashMap<Int, Int>()

    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        hashMap.put(key: key, value: value)
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        guard let value = hashMap.get(key: key) else {
            return -1
        }
        return value
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        hashMap.remove(key: key)
    }
}

---

596ms

struct Pair {
    let key: Int
    let value: Int
}

class ListNode<T> {
    
    var value: T
    
    var next: ListNode<T>?
    
    init(value: T) {
        self.value = value
    }
}

class MyHashMap {
    
    private static let bucketLength = 10_000
    
    private var buckets = [ListNode<Pair>?](repeating: nil, count: MyHashMap.bucketLength)

    /** Initialize your data structure here. */
    init() {
        
    }
    
    /** value will always be non-negative. */
    func put(_ key: Int, _ value: Int) {
        
        let pair = Pair(key: key, value: value)
        
        if let nodes = find(key: key) {
            nodes.node.value = pair // override the current
        } else {
            let hash = hashFromKey(key)
            let index = hash % buckets.count
            
            let newNode = ListNode<Pair>(value: pair)
            newNode.next = buckets[index]
            buckets[index] = newNode
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    func get(_ key: Int) -> Int {
        guard let nodes = find(key: key) else {
          return -1
        }
        return nodes.node.value.value
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    func remove(_ key: Int) {
        guard let nodes = find(key: key) else {
            return // not node found for the key
        }
        
        let node = nodes.node
        
        if let previous = nodes.previous {
            previous.next = node.next
        } else {
            // its the head
            let hash = hashFromKey(key)
            let index = hash % buckets.count 
            buckets[index] = node.next
        }
    }
    
    private func hashFromKey(_ x: Int) -> Int {
        // var x = x
        // x = ((x >> 16) ^ x) * 0x45d9f3b;
        // x = ((x >> 16) ^ x) * 0x45d9f3b;
        // x = (x >> 16) ^ x;
        return x*2654435761
        
//         if key & 1 == 1 { // odd
//             return (key + 1_000_000)
//         } else {
//             return key * 7
//         }
    }
    
    private func find(key: Int) -> (previous: ListNode<Pair>?, node: ListNode<Pair>)? {
        
        let hash = hashFromKey(key)
        let index = hash % buckets.count
        
        var previousNode: ListNode<Pair>? = nil
        var currentNode = buckets[index]
        while let _currentNode = currentNode {
            if _currentNode.value.key == key {
                return (previousNode, _currentNode)
            } 
            
            previousNode = _currentNode
            currentNode = _currentNode.next // keep searching
        }        
        
        return nil // did not find
    }
}