哈希表的插入、查找、删除、遍历java实现

哈希表

散列表（Hash table，也叫哈希表），是根据关键码值(Key
value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash)函数。

散列函数

散列函数能使对一个数据序列的访问过程更加迅速有效，通过散列函数，数据元素将被更快地定位。

实际工作中需视不同的情况采用不同的哈希函数，通常考虑的因素有：

1. 计算哈希函数所需时间
2. 关键字的长度
3. 哈希表的大小
4. 关键字的分布情况
5. 记录的查找频率

求散列函数的几种方法

1. 直接寻址法：取关键字或关键字的某个线性函数值为散列地址。即H(key)=key或H(key) = a·key + b，其中a和b为常数（这种散列函数叫做自身函数）。若其中H(key）中已经有值了，就往下一个找，直到H(key）中没有值了，就放进去。
2. 数字分析法：分析一组数据，比如一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体相同，这样的话，出现冲突的几率就会很大，但是我们发现年月日的后几位表示月份和具体日期的数字差别很大，如果用后面的数字来构成散列地址，则冲突的几率会明显降低。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。
3. 平方取中法：当无法确定关键字中哪几位分布较均匀时，可以先求出关键字的平方值，然后按需要取平方值的中间几位作为哈希地址。这是因为：平方后中间几位和关键字中每一位都相关，故不同关键字会以较高的概率产生不同的哈希地址。
4. 折叠法：将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。移位叠加是将分割后的每一部分的最低位对齐，然后相加；间界叠加是从一端向另一端沿分割界来回折叠，然后对齐相加。
5. 随机数法：选择一随机函数，取关键字的随机值作为散列地址，即H(key)=random(key)其中random为随机函数,通常用于关键字长度不等的场合。
6. 除留余数法：取关键字被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 H(key) = key MOD p,p<=m。不仅可以对关键字直接取模，也可在折叠、平方取中等运算之后取模。对p的选择很重要，一般取素数或m，若p选的不好，容易产生同义词。

代码实现

Emp类

package com.edu.hashtable;

/**
 * @Date 2020/6/4 17:24
 * @Author by hp
 * @Description 雇员表
 */
public class Emp {
    public Integer id;
    public String name;
    public Emp next;

    public Emp(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
}

EmpLinkedList 类

package com.edu.hashtable;

/**
 * @Date 2020/6/4 20:19
 * @Author by hp
 * @Description 雇员链表
 */
public class EmpLinkedList {
    /**
     * 头指针，执行第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
     * 默认为空
     */
    private Emp head;

    /**
     * 添加雇员到链表
     * 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
     * 因此我们将该雇员直接加入到本链表的最后即可
     *
     * @param emp 雇员对象
     */
    public void add(Emp emp) {
        //如果是添加的第一个雇员
        if (head == null) {
            head = emp;
            return;
        }
        //不是第一个雇员,使用辅助指针，定位到最后
        Emp curEmp = head;

        //判断下一个节点是否等于null？
        // 等于null结束循环，不等于空继续后移
        while (curEmp.next != null) {
            //不等于空，继续后移
            curEmp = curEmp.next;
        }

        //退出时直接将emp 加入链表
        curEmp.next = emp;
    }

    /**
     * 遍历链表的雇员信息
     *
     * @param no 表示第几个链表
     */
    public void list(int no) {
        if (head == null) {
            System.out.println("第" + (no + 1) + "个链表为空");
            return;
        }
        System.out.print("第"+(no+1)+"个链表的信息为");
        //辅助指针
        Emp curEmp = head;
        while(true) {
            System.out.printf(" => id=%d name=%s\t", curEmp.id, curEmp.name);
            //说明curEmp已经是最后结点
            if(curEmp.next == null) {
                break;
            }
            //后移，遍历
            curEmp = curEmp.next;
        }
        //换行
        System.out.println();
    }

    /**
     * 根据id 查找雇员
     * @param id 雇员id
     * @return 雇员信息
     */
    public Emp findEmpById(int id){
        if (head==null){
            System.out.println("链表为空");
            return null;
        }
        //辅助指针
        Emp curEmp=head;
        while (true){
            //这时curEmp就指向要查找的雇员
            if (curEmp.id==id){
                break;
            }
            //说明遍历当前链表没有找到该雇员
            if (curEmp.next==null){
                curEmp=null;
                break;
            }
            //向后遍历
            curEmp=curEmp.next;
        }
        return curEmp;
    }

    /**
     * 删除节点
     * @param id
     */
    public void delete(int id){
        if (head==null){
            System.out.println("链表为空");
            return ;
        }
        //辅助指针
        Emp curEmp=head;
        while (true){
            if (head.id==id){
                head=head.next;
                return;
            }
            if (curEmp.next==null){
                break;
            }
            if (curEmp.next.id==id){
                curEmp.next=curEmp.next.next;
            }else {
                System.out.println("找不到需要删除的雇员");
            }
            curEmp=curEmp.next;
        }
    }
}

HashTable 类

package com.edu.hashtable;

/**
 * @Date 2020/6/4 20:39
 * @Author by hp
 * @Description 散列表
 */
public class HashTable {
    /**
     * 哈希数组
     */
    private EmpLinkedList[] empLinkedLists;
    /**
     * 初始大小
     */
    private Integer size;

    public HashTable(int size) {
        this.size = size;
        empLinkedLists = new EmpLinkedList[size];
        //初始化链表，防止空指针异常
        for (int i = 0; i < size; i++) {
            empLinkedLists[i] = new EmpLinkedList();
        }
    }

    /**
     * 添加雇员
     *
     * @param emp 雇员
     */
    public void add(Emp emp) {
        //根绝散列函数确定到哪条链表查找
        int i = hashFun(emp.id);
        //将emp添加到对应的链表中
        empLinkedLists[i].add(emp);
    }

    /**
     * 遍历所有的链表，遍历hashTable
     */
    public void list(){
        for (int i = 0; i < size; i++) {
            empLinkedLists[i].list(i);
        }
    }

    /**
     * 编写散列函数，使用取模法
     * @param id 数值
     * @return 散列值
     */
    private int hashFun(int id) {
        return id % size;
    }

    /**
     * 根据id查找雇员信息
     * @param id 雇员id
     */
    public void findEmpById(int id) {
        //使用散列函数确定到哪条链表查找
        int i = hashFun(id);
        Emp emp = empLinkedLists[i].findEmpById(id);
        if (emp!=null){
            //下标从0开始，所以要＋1
            System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (i + 1), id);
        }else{
            System.out.println("在哈希表中，没有找到该雇员~");
        }
    }

    /**
     * 删除雇员信息
     * @param id 雇员id
     */
    public void delete(int id){
        int i = hashFun(id);
        empLinkedLists[i].delete(id);
    }
}

本文引用百度百科，尚硅谷韩顺平数据结构与算法

如有兴趣的读者还可以前往我github查看我学习时的代码 github地址