java实现自定义哈希表

哈希表实现原理

哈希表底层是使用数组实现的，因为数组使用下标查找元素很快。所以实现哈希表的关键就是把某种数据类型通过计算变成数组的下标（这个计算就是hashCode()函数***

怎么把一个字符串转化成整数下标呢？

• 可以把每个字符的ASCII对应的数字相加作为下标，比如"abc"=(a-96)+(b-96)+(c-96),'a'的ASCII是97;这种方式的缺点就是哈希值很容易重复，比如aaa,abc,cab
• 也可以使用幂的连乘，保证不同字符串算出来的哈希值不一样，这种方式的缺点是会算出来的哈希值会发生数值越界
• 解决越界问题可以使用大数运算，java里的BitInt

实现

首先创建数据类型

package dataS.hash;

import java.util.Objects;

public class Info {
    //员工号
    private String key;
    //员工值
    private String value;

    public Info(String key, String value) {
        this.key = key;
        this.value = value;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
    @Override
    public String toString() {
        return "Info{" +
                "key='" + key + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Info info = (Info) o;
        return Objects.equals(key, info.key) &&
                Objects.equals(value, info.value);
    }
}

创建HashTable类

package dataS.hash;

import java.math.BigInteger;

public class HashTable {
    private Info[] arrays;

    /**
     * 默认构造方法,默认数组大小100
     */
    public HashTable() {
        this.arrays = new Info[100];
    }
    /**
     * 指定大小
     */
    public HashTable(int maxsize){
        this.arrays=new  Info[maxsize];
    }

    /**
     * 插入数据,直接把员工号作为数组索引
     */
    public void insert(Info info){
        this.arrays[hashCode(info.getKey())]=info;

    }
    /**
     * 查找数据,直接把员工号作为数组索引
     */
    public Info find(String key){
        return arrays[hashCode(key)];
    }
    public int hashCode(String key){
        return hash3(key);

    }

    public int hash1(String key){
        //1.将字母转化成ASCII,然后相加
        int hashvalue=0;
        for (int i = 0; i < key.length(); i++) {
            //a是97,其他字母减去97就是字母对应的数字
            int letter=key.charAt(i)-96;
            hashvalue+= letter;
        }
        //取模可以压缩可选值，比如想把100个可选择压缩到0-9,对数组长度取模
        return hashvalue%arrays.length;
    }
    public int hash2(String key){
        //2.幂的连乘,这里可能hashvalue的值超过范围，使用long也不行，可以用bigint
        int hashvalue=0;
        int pow27=1;
        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+2*27^2
            int letter=key.charAt(i)-96;
            hashvalue+= letter*pow27;
            pow27*=27;
        }
        return hashvalue%arrays.length;
    }
    public int hash3(String key){
        //3.用bigint

        BigInteger hashvalue=new BigInteger("0");
        BigInteger pow27=new BigInteger("1");

        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+3*27^2

            int letter=key.charAt(i)-96;
            //把letter用bigint包装起来
            BigInteger bigLetter=new BigInteger(letter+"");
            hashvalue=hashvalue.add(bigLetter.multiply(pow27));
            pow27=pow27.multiply(new BigInteger(27+""));
        }
        return hashvalue.mod(new BigInteger(arrays.length+"")).intValue();
    }

}

测试

package dataS.hash;

public class HashTest {
    public static void main(String[] args) {
        HashTable hashTable=new HashTable();
        hashTable.insert(new Info("a","111"));
        hashTable.insert(new Info("tc","222"));
        hashTable.insert(new Info("cba","333"));

        System.out.println(hashTable.find("a").getValue());
        System.out.println(hashTable.find("tc").getValue());
        System.out.println(hashTable.find("cba").getValue());
    }
}

发现tc把a的位置给占用了

冲突解决

为什么会有冲突呢？因为我压缩了可选值(进行了取模运算)，比如我想把1和101个元素放到大小为10的数组，对10取模后下标都是1，肯定会发生冲突

开放地址法

把一号位置占用了，101就看2号位置有没有被占用，直到找到空位置，然后插入。主要101原本想插入的位置和最终插入位置一定是连续的，中间不会有空位置

修改插入删除和查找方法

package dataS.hashTwo;

import java.math.BigInteger;

public class HashTable {
    private Info[] arrays;

    /**
     * 默认构造方法,实现哈希表的本质是哈希函数将不同类型的数据转化成数组下表
     */
    public HashTable() {
        this.arrays = new Info[100];
    }
    /**
     * 指定大小
     */
    public HashTable(int maxsize){
        this.arrays=new Info[maxsize];
    }

    /**
     * 插入数据,直接把员工号作为数组索引
     */
    public void insert(Info info){
        String key=info.getKey();
        //关键字对应的哈希值，将要作为下标
        int hashValue=hash3(key);

        //如果被占用，并且key对应的value也不为空（因为删除的时候是删除info对象里的value,而不是全部）
        while (arrays[hashValue]!=null&&arrays[hashValue].getValue()!=null){
            //一直找到一个没被占用的
            hashValue++;
            //比如99和599哈希值取模后都是99，99加1后数组会越界，但是前面还有空的位置
            hashValue%=arrays.length;
            //直到整个数组都填满
        }
        arrays[hashValue]=info;

    }
    /**
     * 查找数据,直接把员工号作为数组索引
     */
    public Info find(String key){
        int hashValue=hash3(key);
        //从第一次的位置，到最终插入位置是连续的
        while (arrays[hashValue]!=null){
            //如果key值相等说明找到了
            if(arrays[hashValue].getKey().equals(key))
                return arrays[hashValue];
            hashValue++;
            hashValue%=arrays.length;
        }
        return null;
    }
    public Info delete(String key){
        int hashValue=hash3(key);
        //从第一次的位置，到最终插入位置是连续的
        while (arrays[hashValue]!=null){
            //如果key值相等说明找到了,将Info的value值空
            if(arrays[hashValue].getKey().equals(key)){
                Info info=arrays[hashValue];
                arrays[hashValue].setValue(null);
                return info;
            }
            hashValue++;
            hashValue%=arrays.length;
        }
        return null;
    }
    public int hashCode(String key){
        return hash3(key);

    }

    public int hash1(String key){
        //1.将字母转化成ASCII,然后相加
        int hashvalue=0;
        for (int i = 0; i < key.length(); i++) {
            //a是97,其他字母减去97就是字母对应的数字
            int letter=key.charAt(i)-96;
            hashvalue+= letter;
        }
        //取模可以压缩可选值，比如想把100个可选择压缩到0-9,对数组长度取模
        return hashvalue%arrays.length;
    }
    public int hash2(String key){
        //2.幂的连乘,这里可能hashvalue的值超过范围，使用long也不行，可以用bigint
        int hashvalue=0;
        int pow27=1;
        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+2*27^2
            int letter=key.charAt(i)-96;
            hashvalue+= letter*pow27;
            pow27*=27;
        }
        return hashvalue%arrays.length;
    }
    public int hash3(String key){
        //3.用bigint

        BigInteger hashvalue=new BigInteger("0");
        BigInteger pow27=new BigInteger("1");

        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+3*27^2

            int letter=key.charAt(i)-96;
            //把letter用bigint包装起来
            BigInteger bigLetter=new BigInteger(letter+"");
            hashvalue=hashvalue.add(bigLetter.multiply(pow27));
            pow27=pow27.multiply(new BigInteger(27+""));
        }
        return hashvalue.mod(new BigInteger(arrays.length+"")).intValue();
    }

}

测试

发现冲突问题解决了

链地址法:

实现原理，将一个个链表作为数组的元素，当发生冲突就将冲突元素链接到对应的链表后面

不同的哈希值对应一个不同的链表，哈希值相同的串在一起

链表结构，实现增删查功能

public class LinkedNode {
    public Info info;
    public LinkedNode next;

    public LinkedNode(Info info) {
        this.info = info;
    }
}

package dataS.hashThree;

public class Linked {
    public LinkedNode head;

    public Linked() {
        head = null;
    }

    //插入节点,在头结点之后插入.
    //重点是不要让节点丢失
    public void insert(Info info) {
        LinkedNode node = new LinkedNode(info);

        if (head == null) {
            head = node;
        } else {
            node.next = head.next;
//        head.next=node;此处不应该这么写，会形成环
            head.next = node;
        }

    }

    //在头结点之后删除一个元素
    public LinkedNode delete() throws Exception {
        if(head.next==null){
            head=null;
            return null;

        }else{
            LinkedNode tmp = head.next;
            head.next = tmp.next;
            return tmp;
        }
    }

    //查找方法
    public LinkedNode find(String key) {
        LinkedNode tmp = head;
        if(tmp==null)
            return null;
        while (!key.equals(tmp.info.getKey())){

            if(tmp.next==null)
                return null;
            tmp=tmp.next;
        }
        return tmp;
    }
    //根据值来删除元素
    public LinkedNode deleteByvalue(String  key){
        LinkedNode ans = null;
        LinkedNode pretmp = head;
        LinkedNode tmp =head.next;

        if(key.equals(head.info.getKey())){
            ans=head;
            head=head.next;
            return ans;
        }
        while (tmp!=null){
            if(key.equals(tmp.info.getKey())){
                ans=tmp;
                pretmp.next=tmp.next;
            }
            pretmp=pretmp.next;
            tmp=tmp.next;
        }
        return ans;
    }
}

哈希表

package dataS.hashThree;

import java.math.BigInteger;

public class HashTable {
    private Linked[] arrays;

    /**
     * 默认构造方法,实现哈希表的本质是哈希函数将不同类型的数据转化成数组下表
     */
    public HashTable() {
        this.arrays = new Linked[100];
    }
    /**
     * 指定大小
     */
    public HashTable(int maxsize){
        this.arrays=new Linked[maxsize];
    }

    /**
     * 插入数据,直接把员工号作为数组索引
     */
    public void insert(Info info){
        String key=info.getKey();
        //关键字对应的哈希值，将要作为下标
        int hashValue=hash3(key);
        //
        if(arrays[hashValue]==null){
            arrays[hashValue]=new Linked();
        }
        //插入
        arrays[hashValue].insert(info);

    }
    /**
     * 查找数据,直接把员工号作为数组索引
     */
    public Info find(String key){
        int hashValue=hash3(key);
        //从第一次的位置，到最终插入位置是连续的

        LinkedNode node = arrays[hashValue].find(key);
        if(node==null)
            return null;
        return node.info;
    }
    public Info delete(String key){
        int hashValue=hash3(key);
        //从第一次的位置，到最终插入位置是连续的
        LinkedNode node = arrays[hashValue].deleteByvalue(key);
        return node.info;
    }
    public int hashCode(String key){
        return hash3(key);

    }

    public int hash1(String key){
        //1.将字母转化成ASCII,然后相加
        int hashvalue=0;
        for (int i = 0; i < key.length(); i++) {
            //a是97,其他字母减去97就是字母对应的数字
            int letter=key.charAt(i)-96;
            hashvalue+= letter;
        }
        //取模可以压缩可选值，比如想把100个可选择压缩到0-9,对数组长度取模
        return hashvalue%arrays.length;
    }
    public int hash2(String key){
        //2.幂的连乘,这里可能hashvalue的值超过范围，使用long也不行，可以用bigint
        int hashvalue=0;
        int pow27=1;
        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+2*27^2
            int letter=key.charAt(i)-96;
            hashvalue+= letter*pow27;
            pow27*=27;
        }
        return hashvalue%arrays.length;
    }
    public int hash3(String key){
        //3.用bigint

        BigInteger hashvalue=new BigInteger("0");
        BigInteger pow27=new BigInteger("1");

        for (int i = 0; i < key.length(); i++) {
            //比如abc,1*27^0+2*27^1+3*27^2

            int letter=key.charAt(i)-96;
            //把letter用bigint包装起来
            BigInteger bigLetter=new BigInteger(letter+"");
            hashvalue=hashvalue.add(bigLetter.multiply(pow27));
            pow27=pow27.multiply(new BigInteger(27+""));
        }
        return hashvalue.mod(new BigInteger(arrays.length+"")).intValue();
    }
    public int hash4(String key){
        //3.使用开放地址法解决冲突
        //当冲突发生，查找空位置插入，而不再用哈希函数得到数组下标

        return 1;
    }
}

测试

发现冲突解决了

总结

哈希表的本质是数组，学会hashCode的实现方式，数据的压缩，掌握解决冲突的俩种办法

重点是链地址法，比开放地址法高效简洁