哈希表（散列表）

最新推荐文章于 2023-05-23 13:34:12 发布

MiemieWan

最新推荐文章于 2023-05-23 13:34:12 发布

阅读量430

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/MiemieWan/article/details/106351499

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、散列表的特点

散列表是基于数组进行实现的，他的结构就是数组，它是对下标值的一种变换。

散列表的优点：

散列表可非常快速的插入、删除、查找。无论多少数据，插入和删除只需要接近常量的时间:O(1),只需要几个机器指令即可完成。
散列表的速度比树还要快，基本可以瞬间查找到想要的元素
哈希表相对于树来说编码要容易很多。

散列表的不足：

散列表中的数据是没有顺序的，所以不能以固定的方式（比如从小到大）来遍历其中的元素。
哈希表中的key是不允许重复的，不能放置相同的key用于保存不同的元素。

二、散列表的实际应用

案例：保存联系人和电话

方案：将联系人的名字（字符串）转成下标值，就是哈希函数。方便查找，效率高。

三、散列表基本实现

根据键名，通过散列函数（转换成哈希值并相加 % 37)，得到散列值，将散列值作为键名，与值组成键值对，存入散列表。

代码实现：

var HashTable = function() {
    var items = [];
    // 散列函数：将key转化为哈希值再相加，返回散列值
    var loseloseHashCode = function(key) {
        var hash = 0;
        for(var i = 0; i < key.length; i++) {
            hash += key[i].charCodeAt(); // charCodeAt():将字符转成哈希码
        }
        return hash % 37; // 取余
    }
    // put 添加
    this.put = function(key,value) {
        var position = loseloseHashCode(key);
        items[position] = value;
    }
    // remove 
    this.remove = function(key) {
        items[loseloseHashCode(key)] = undefined;
    }
    // get 获取value
    this.get = function(key) {
        return items[loseloseHashCode(key)];
    }
    // getItem 获取整个散列表
    this.getItem = function() {
        return items;
    }
}    
var hashTable = new HashTable()
hashTable.put('Jobs','Jobs@qq.com');
hashTable.put('Bob','Bob@qq.com');
console.log(hashTable.getItem());
console.log(hashTable.get('Jobs'));
hashTable.remove('Bob')
console.log(hashTable.getItem());

四、解决散列表冲突的方法

当两个散列值相同时，如果按上述添加方法直接添加，则Donnie会被覆盖掉，造成数据丢失。

解决方法有：

（1）分离链表法（链地址法）：在散列值为13的地方添加一个链表，将Donnie和Ana都append到链表上

（2）开放地址法

线性探查法：当散列值为13的地方已经有数据，就放到散列值为14的地方，x+1,x+2,x+3...依次探查
二次探查法：当13到后面的空间连续有数据时，可以用二次探查法，探查更长的数据，x+,,...依次探查
再哈希法：新的低重复率散列函数

五、哈希化的效率

链地址法：

线性探查法：

二次探查法和再哈希化：

五、解决散列表冲突 ——链地址法（分离链表法）

链地址法：

实现方法：

put(key,value)：添加：获取key的散列值position，判断该位置是否有内容，如果没有则创建链表，链表放到该位置，并将ele插入链表；如果该位置已经有内容，则直接插入链表尾。注意：ele的形式设为{key:value},方便后面根据key做查找。

    // 辅助类：创建链表ele
    var EleNode = function(key,value) {
        this.key = key;
        this.value = value;
    }

    // put 添加
    this.put = function(key,value) {
        var position = loseloseHash(key);
        var eleNode = new EleNode(key, value);
        // 判断该位置上是否有内容
        if(items[position]) {
            items[position].append(eleNode);
        } else {
            // 该位置上没有内容时，创建链表，并将node放入链表中
            var linkList = new LinkList();
            items[position] = linkList;
            linkList.append(eleNode);
        }
    }

get(key): 获取某个值：获取key的散列值position，在该位置有链表的情况下，循环链表中的像找到key，返回其value值

    // get 获取value
    // 因为ele是{key:value}形式，所以在对比的时候要写ele.key
    this.get = function(key) {
        var position = loseloseHash(key);
        if(items[position]) {
            var current = items[position].getHead();
            while(current) {
                if(current.ele.key == key) {
                    return current.ele.value;
                } else {
                    current = current.next;
                }
            }
            return undefined;
        } else {
            return undefined;
        }
    }

remove(key):删除某项：获取key的散列值position，在该位置有链表的情况下，循环链表中的像找到key，调用链表的移除ele方法。如果链表为空，则删除链表，防止一直占用内存空间。

    // remove 删除
    this.remove = function(key) {
        var position = loseloseHash(key);
        if(items[position]) {
            var current = items[position].getHead();
            while(current) {
                if(current.ele.key == key) {
                    // 调用链表的移除ele方法
                    items[position].remove(current.ele);
                    // 如果链表为空，则删除链表，防止一直占用内存空间
                    if(items[position].isEmpty()) {
                        items[position] = undefined;
                    }
                    return true;
                } 
                current = current.next;
            }
        }
        return false;
    }

整体代码实现：

// 链表
var LinkList = function() {
    var length = 0;
    var head = null;
    var LinkNode = function(ele) {
        this.ele = ele;
        this.next = null;
    }
    // append 尾部添加
    this.append = function(ele) {
        var linkNode = new LinkNode(ele);
        if(head == null) {
            head = linkNode;
        } else {
            var current = head;
            while(current.next) {
                current = current.next;
            }
            current.next = linkNode;
        }
        length ++ ;
    }

    // insert 插入
    this.insert = function(position, ele) {
        var linkNode = new LinkNode(ele);
        if(position > -1 && position < length) {
            if(position == 0) {
                var current = head;
                head = linkNode;
                head.next = current;
            } else {
                var previous = null;
                var current = head;
                var index = 0;
                while(index < position) {
                    previous = current;
                    current = current.next;
                    index ++ ;
                }
                previous.next = linkNode;
                linkNode.next = current;
            }
            length ++ ;
        }
    }

    // removeAt 根据位置删除
    this.removeAt = function(position) {
        var previous = null;
        var current = head;
        var index = 0;
        if(position > -1 && position < length) {
            if(position == 0) {
                head = current.next;
            } else {
                while(index < position) {
                    previous = current;
                    current = current.next;
                    index ++;
                }
                previous.next = current.next;
            }
            length --;
            return current;
        }
        
    }

    // indexOf 根据值查找位置
    this.indexOf = function(ele) {
        var current = head;
        var index = 0;
        while(current) {
            if(current.ele == ele) {
                return index;
            } else {
                current = current.next;
                index ++ ;
            }
        }
        return -1;
    }

    // remove 根据值删除
    this.remove = function(ele) {
        return this.removeAt(this.indexOf(ele));
    }

    // getHead 获取链表头
    this.getHead = function(){
        return head;
    }

    this.isEmpty = function() {
        return length == 0;
    }
}
// var linkList = new LinkList();
// linkList.append(3)
// linkList.append(4)
// linkList.append(5)
// linkList.insert(1,9)
// linkList.removeAt(0)
// console.log(linkList.indexOf(5));
// linkList.remove(5)
// console.log(linkList.getHead());


// 分离链表
var HashTable = function() {
    var items = [];

    var loseloseHash = function(key) {
        var hash = 0;
        for(var i = 0; i < key.length; i++) {
            hash += key[i].charCodeAt();
        }
        return hash % 37;
    }
    
    // 辅助类：创建链表ele
    var EleNode = function(key,value) {
        this.key = key;
        this.value = value;
    }

    // put 添加
    this.put = function(key,value) {
        var position = loseloseHash(key);
        var eleNode = new EleNode(key, value);
        // 判断该位置上是否有内容
        if(items[position]) {
            items[position].append(eleNode);
        } else {
            // 该位置上没有内容时，创建链表，并将node放入链表中
            var linkList = new LinkList();
            items[position] = linkList;
            linkList.append(eleNode);
        }
    }
    // get 获取value
    // 因为ele是{key:value}形式，所以在对比的时候要写ele.key
    this.get = function(key) {
        var position = loseloseHash(key);
        if(items[position]) {
            var current = items[position].getHead();
            while(current) {
                if(current.ele.key == key) {
                    return current.ele.value;
                } else {
                    current = current.next;
                }
            }
            return undefined;
        } else {
            return undefined;
        }
    }

    // remove 删除
    this.remove = function(key) {
        var position = loseloseHash(key);
        if(items[position]) {
            var current = items[position].getHead();
            while(current) {
                if(current.ele.key == key) {
                    // 调用链表的移除ele方法
                    items[position].remove(current.ele);
                    // 如果链表为空，则删除链表，防止一直占用内存空间
                    if(items[position].isEmpty()) {
                        items[position] = undefined;
                    }
                    return true;
                } 
                current = current.next;
            }
        }
        return false;
    }


    // 获取
    this.getItem = function() {
        return items;
    }
}
var hashTable = new HashTable();
hashTable.put('Donnie','Donnie');
hashTable.put('Ana','Ana');
hashTable.put('anA','anA');
console.log(hashTable.getItem()[13].getHead());
console.log(hashTable.get('hfgdf'));
console.log(hashTable.get('Ana'));
console.log(hashTable.get('Donnie'));
console.log(hashTable.get('anA'));
hashTable.remove('Donnie')
hashTable.remove('Ana')
hashTable.remove('anA')
console.log(hashTable.getItem()[13]);

三、解决散列表冲突 ——线性探查法

put(key,value): 添加：获取key的散列值，查看该位置是否有内容，如果没有就直接把节点放进去，如果有就向下查找空位置。

var HashTable = function() {
    var items = [];
    var loseloseHash = function(key) {
        var hash = 0;
        for(var i = 0; i< key.length;i++) {
            hash += key[i].charCodeAt();
        }
        return hash % 37;
    }
    var Node = function(key,value) {
        this.key = key;
        this.value = value;
    }

    this.put = function(key,value) {
        var position = loseloseHash(key);
        var node = new Node(key,value);
        if(items[position] == undefined) {
            items[position] = node;
        } else {
            var index = position + 1;
            while(items[index] != undefined) {
                index++;
            }
            items[index] = node;
        }
    }
    this.getItem = function() {
        return items;
    }
}    
var hashTable = new HashTable();
hashTable.put('anA','anA')
hashTable.put('Donnie','Donnie')
console.log(hashTable.getItem());

四、解决散列表冲突 —— 新的低重复率散列函数

var loseloseHash = function(key) {
    var hash = 5381;
    for(var i = 0; i < key.length; i++) {
        hash = hash * 33 + key[i].charCodeAt();
    }
    return hash % 1013;
}

MiemieWan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
哈希表（散列表）

一、散列表基本实现根据键名，通过散列函数（转换成哈希值并相加% 37)，得到散列值，将散列值作为键名，与值组成键值对，存入散列表。代码实现：var HashTable = function() { var items = []; // 散列函数：将key转化为哈希值再相加，返回散列值 var loseloseHashCode = function(key) { var hash = 0; for(var i = 0; i &l..
复制链接

扫一扫

专栏目录