JS数据结构与算法 —— 散列表（哈希表）

概念：散列表（Hash table，也叫哈希表），是根据关键码-值(Key-value)的形式进行存储和访问的数据结构。

散列表类似于字典，是以 键-值(Key-value) 对形式存储的数据结构，不同点在于散列表的键key是经过散列函数计算得出，我们称之为关键码，每个关键码都对应一个值，我们把这种以 关键码-值 形式存储数据的数组称为散列表。

 作用：可以快速定位元素，并拿到对应的值。相比其他数据结构需要遍历元素来取值，而散列表可以直接通过关键码来找到对应的值。

操作方法：put()增加元素，remove()移除元素，get()获取元素

散列表的核心是散列函数，键名通过散列函数转换成关键码，并把值以 关键码-值 存在于散列表里。当需要查找某个值时，可以通过查找关键码快速定位目标值所在的位置，然后取值。下面用js里的数组来实现一个普通散列表：

HashTable类表示一个普通散列表（哈希表）

class HashTable{
    constructor(){
        this.table = []         // 散列表
    }
    /* 散列函数1：冲突相对比较 */
    loseloseHashCode(key){      // 通过ASCII码转换生成key
        let hash = 0
        for (let i = 0; i< key.length; i++) {
           hash += key[i].charCodeAt()      // 计算key的ASCII码
        }
        return hash%37         // loseloseHashCode方法计算关键码的公式，即 ASCII码取余37   
    }
    /* 新增元素 */
    put(key,value){
        const position = this.loseloseHashCode(key)       // 元素在散列表里的地址
        this.table[position] = value
    }
    /* 移除元素 */
    remove(key){
        this.table[this.loseloseHashCode(key)] = undefined
    }
    /* 获取元素 */
    get(key){
        return this.table[this.loseloseHashCode(key)]
    }
}

上面散列函数有一个缺陷，也就是计算出来的关键码有可能会相同，以至于在存储过程中会产生冲突。下面介绍两个改善的方法，可以更好的避免此类问题的发生。

线性探查法解决冲突

原理：当遇到关键码冲突时，使下标加一继续往后查找，直到找到空的地址，然后把散列值存储在该位置。

相比于普通的散列表，线性探查法实现的散列表它在添加元素时做了特殊处理，普通散列表通过查找到关键码所在的位置直接插入值，而线性探查法是查找到关键码所在位置，并判断该位置是否有值，如果有值则关键码（下标）+1继续查找下一个位置，直到查找的位置为空，然后插入值。

定义一个辅助类Node，表示新节点

class __Node{
    constructor(key,value){
        this.key = key
        this.value = value
    }
}

散列表类HashTable_Line，及散列函数

class HashTable_Line{
    constructor(){
        this.table = []         
    }
    loseloseHashCode(key){
        let hash = 0 
        for(let i=0; i<key.length; i++){
            hash += key[i].charCodeAt()
        }
        return hash%37
    }
}

其中HashTable_Line类里包含了以下几个操作方法

插入元素

put(key,value){
    const position = this.loseloseHashCode(key)
    const node = new __Node(key,value)
    if(this.table[position]){         // 如果该位置已经有值
        let index = position                    // 当前查找位置的下标
        while(this.table[index]!==undefined){   // 如果当前位置的值不为undefined，说明也有值
            index++                             // 继续查找下一个，下标加一
        }
        this.table[index] = node                // 直到当前位置没有值，存储在该位置
    } else{
        this.table[position] = node   // 如果没值，直接赋值
    }
}

移除元素 

remove(key){
    const position = this.loseloseHashCode(key)
    if (this.table[position]) {
        let index = position
        while(this.table[index].key !== key){
            index++
        }
        this.table[index] = undefined
        return true
    } else {
        return false
    }
}

查找某个元素

get(key){
    const position = this.loseloseHashCode(key)
    if (this.table[position]) {
        let index = position
        while(this.table[index].key !== key){
            index++
        }
        return this.table[index]
    } else {
        return false
    }
}

分离链接法解决冲突

原理：把散列表的值存储在一个链表里。

该方法实现的散列表存储形式是一个关键码对应一个链表，关键码相同的值依次存储在链表上，这样就避免了键-值对形式的冲突。如下为js的实现过程：

新节点辅助类Node

class _Node{
    constructor(key,value){
        this.key = key
        this.value = value
    }
}

散列表类HashTable_LinkedList，及散列函数

class HashTable_LinkedList{
    constructor(){
        this.table = []         // 散列表
    }
    loseloseHashCode(key){      // 通过ASCII码转换生成key
        let hash = 0            
        for (let i = 0; i< key.length; i++) {
           hash += key[i].charCodeAt()      // 计算key的ASCII码
        }
        return hash%37         // loseloseHashCode方法计算关键码的公式，即 ASCII码的和 取余37   
    }
}

其中HashTable_LinkedList类包含了如下几个方法

新增元素

put(key,value){
    const position = this.loseloseHashCode(key)   // 元素在散列表中的存储地址
    const l = new LinkedList()
    const node = new _Node(key,value)
    if(!this.table[position]){        // 还没有链表（此位置还没有值）  
        this.table[position] = l
        l.append(node)                // 链表的append方法新增元素
    }
    else{                             // 已存在链表   
        this.table[position].append(node)
    }
}

移除元素

remove(key){
    const position = this.loseloseHashCode(key)
    if (this.table[position]) {                    // 已存在链表
        let current = this.table[position].head     // 链表
        while(current){
            if(current.element.key == key){
                this.table[position].remove(current.element)     //调用链表的remove方法删除元素
                if(this.table[position].isEmpty()){
                    this.table[position] = undefined        // 如果该链表为空，则设置此散列值为undefined，释放内存
                }
                return true
            }
            current = current.next
        }
    } else {
        return false        // 该元素不存在         
    }
}

获取元素

get(key){
    const position = this.loseloseHashCode(key)
    if(this.table[position]){
        let current = this.table[position].head
        while(current){
            if(current.element.key == key){
                return current.element.value
            }
            current = current.next
        }
    }else{
        return undefined
    }
}

完整代码

更多数据结构相关，请查看专栏：《JavaScript数据结构与算法》