[Swift]LeetCode705. 设计哈希集合 | Design HashSet

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

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

To be specific, your design should include these functions:

• add(value): Insert a value into the HashSet. 
• contains(value) : Return whether the value exists in the HashSet or not.
• remove(value): Remove a value in the HashSet. If the value does not exist in the HashSet, do nothing.

Example:

MyHashSet hashSet = new MyHashSet();
hashSet.add(1);         
hashSet.add(2);         
hashSet.contains(1);    // returns true
hashSet.contains(3);    // returns false (not found)
hashSet.add(2);          
hashSet.contains(2);    // returns true
hashSet.remove(2);          
hashSet.contains(2);    // returns false (already removed)

Note:

• All 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 HashSet library.

---

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

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

• add(value)：向哈希集合中插入一个值。
• contains(value) ：返回哈希集合中是否存在这个值。
• remove(value)：将给定值从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。

示例:

MyHashSet hashSet = new MyHashSet();
hashSet.add(1);         
hashSet.add(2);         
hashSet.contains(1);    // 返回 true
hashSet.contains(3);    // 返回 false (未找到)
hashSet.add(2);          
hashSet.contains(2);    // 返回 true
hashSet.remove(2);          
hashSet.contains(2);    // 返回  false (已经被删除)

注意：

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

---

456ms

class MyHashSet {

    var map = [Bool](repeating: false, count: 1000000)
    
    /** Initialize your data structure here. */
    init() {
        
    }
    
    func add(_ key: Int) {
        map[key] = true
    }
    
    func remove(_ key: Int) {
        map[key] = false
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        return map[key]
    }
}

/**
 * Your MyHashSet object will be instantiated and called as such:
 * let obj = MyHashSet()
 * obj.add(key)
 * obj.remove(key)
 * let ret_3: Bool = obj.contains(key)
 */

---

Runtime: 432 ms

Memory Usage: 20.8 MB

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

class MyHashSet {
    
    private var nums: [LinkedNode?]

    /** Initialize your data structure here. */
    init() {
        nums = Array(repeating: nil, count: 10000)
    }
    
    func add(_ key: Int) {
        let index = hash(key)
        if let node = nums[index] {
            var next: LinkedNode? = node
            var pre: LinkedNode? = nil
            while next != nil {
                if next!.val == key {
                    return
                }
            
                pre = next
                next = next?.next
            }
            
            pre?.next = LinkedNode(key)
        } else {
            nums[index] = LinkedNode(key)
        }
    }
    
    func remove(_ key: Int) {
        let index = hash(key)
        guard let node = nums[index] else {
            return
        }
        
        var next: LinkedNode? = node
        var pre: LinkedNode? = nil
        while next != nil {
            if next!.val == key {
                if pre != nil {
                    pre?.next = next!.next
                } else {
                    nums[index] = next!.next
                }
                break
            }
            
            pre = next
            next = next?.next
        }
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        let index = hash(key)
        guard let node = nums[index] else {
            return false
        }
        
        var next: LinkedNode? = node
        while next != nil {
            if next!.val == key {
                return true
            }
            
            next = next?.next
        }
        
        return false
    }
    
    func hash(_ key: Int) -> Int {
        return key % 10000
    }
    
}

/**
 * Your MyHashSet object will be instantiated and called as such:
 * let obj = MyHashSet()
 * obj.add(key)
 * obj.remove(key)
 * let ret_3: Bool = obj.contains(key)
 */ 

---

460ms

class MyHashSet {
    
    var buckets: [[Int]]
    let MAX_LENGTH = 10000
    /** Initialize your data structure here. */
    init() {
        buckets = Array(repeating:[Int](), count: MAX_LENGTH)
    }
    
    private func getIndex(_ key: Int) -> Int {
        return key % MAX_LENGTH
    }
    
    func add(_ key: Int) {
      if !self.contains(key) {
        buckets[getIndex(key)].append(key)    
      }
      
    }
    
    func remove(_ key: Int) {
       let bucketIndex = getIndex(key)
        for i in (0..<buckets[bucketIndex].count).reversed() {
            if buckets[bucketIndex][i] == key {
                buckets[bucketIndex].remove(at: i)
            }
        }
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        let bucketIndex = getIndex(key)
        for item in buckets[bucketIndex] {
            if item == key {
                return true
            }
        }
        return false
    }
}

---

488ms

class MyHashSet {
    var hash = [[Int]](repeating:[Int](), count: 1000)
    /** Initialize your data structure here. */
    init() {
        
    }
    
    func add(_ key: Int) {
        let hashKey = key % 1000
        if !contains(key) {
            hash[hashKey].append(key)
        }
    }
    
    func remove(_ key: Int) {
        let hashKey = key % 1000
        hash[hashKey] = hash[hashKey].filter { $0 != key }
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        let hashKey = key % 1000
        if !hash[hashKey].contains(key) {
            return false
        } else {
            return true
        }
    }
}

---

508ms

class MyHashSet {
    
    private var array = [Bool]()

    /** Initialize your data structure here. */
    init() {
        
    }
    
    func add(_ key: Int) {
        if array.count <= key {
            array += Array(repeating: false, count: key - array.count + 1)
        }
        
        array[key] = true
    }
    
    func remove(_ key: Int) {
        if array.count <= key {
            return
        }
        array[key] = false
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        if array.count <= key {
            return false
        }
        return array[key]
    }
}

---

512ms

class MyHashSet {

    var hashset: [ Int ]

    /** Initialize your data structure here. */
    init() {
        hashset = [ Int ](repeating: 0, count: 1000000 >> 6) // 64-bit
    }
    
    func offset(_ key: Int) -> (Int, Int) {
        let byte = key >> 6
        let bit = 1 << (key % 64)
        return (byte, bit)
    }
    
    func add(_ key: Int) {
        let (byte, bit) = offset(key)
        hashset[byte] |= bit
    }
    
    func remove(_ key: Int) {
        let (byte, bit) = offset(key)
        hashset[byte] &= (bit ^ -1)
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        let (byte, bit) = offset(key)
        return hashset[byte] & bit != 0
    }
}

---

516ms

class MyHashSet {
    
    private var array = [Bool]()

    /** Initialize your data structure here. */
    init() {
        
    }
    
    func add(_ key: Int) {
        if array.count <= key {
            array += Array(repeating: false, count: key - array.count + 1)
        }
        
        array[key] = true
    }
    
    func remove(_ key: Int) {
        if array.count <= key {
            return
        }
        array[key] = false
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        if array.count <= key {
            return false
        }
        return array[key]
    }
}

---

684ms

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

class MyHashSet {
    
    private var nodes: [LinkedNode?]

    /** Initialize your data structure here. */
    init() {
        nodes = Array(repeating: nil, count: 10000)
    }
    
    func add(_ key: Int) {
        let index = hash(key)
        guard let node = nodes[index] else {
            nodes[index] = LinkedNode(key)
            return
        }
        
        var next: LinkedNode? = node
        var pre: LinkedNode? = nil
        while next != nil, next!.val != key {
            pre = next
            next = next?.next
        }
        
        if next == nil {
            pre?.next = LinkedNode(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!.val != key {
            pre = next
            next = next?.next
        }
        
        if let pre = pre {
            pre.next = next?.next
        } else {
            nodes[index] = next?.next
        }
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        let index = hash(key)
        guard let node = nodes[index] else {
            return false
        }
        
        var next: LinkedNode? = node
        while next != nil, next!.val != key {
            next = next?.next
        }
        
        return next != nil
    }
    
    private func hash(_ key: Int) -> Int {
        return key % 10000
    }    
}

---

860ms

class MyHashSet {
    var values: [Int]
    /** Initialize your data structure here. */
    init() {
        values = Array.init(repeating: -1, count: 1000000)
    }
    
    func add(_ key: Int) {
        values[key] = key
    }
    
    func remove(_ key: Int) {
        values[key] = -1
    }
    
    /** Returns true if this set contains the specified element */
    func contains(_ key: Int) -> Bool {
        if key < values.count {
            return values[key] != -1
        }
        
        return false
    }
}