数据结构与算法-哈希表（java实现）

1.概念

欢迎访问我的个人博客（点击进入）
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

简单来说，哈希表就是根据关键码值来迅速定位到表中的一个位置进行访问，以加快查找的速度。

2.散列函数

前面提到了关键码值，那么关键码值是如何确定的呢？

这就涉及到了散列函数，哈希表通过关键码值来映射到表中的一个位置来访问，这个映射函数就叫做散列函数。

2.1 取余散列法

本文就通过简单的取余散列法来映射的表中的位置

这是哈希表的图示，可以看到左边是一个数组，而每一个数组的元素后面都连接了一个链表。

这里我们模拟一种真实的场景，用哈希表存放员工信息，关键值为员工的id，我们通过取余法将员工的id分配到左边数组中的元素上
即: index = value % 15

这样就可以将关键值映射的对应的index上，然后再对该index后面挂的链表进行搜索就可以搜索到需要找的员工id。

其他还有很多种散列函数，本文就以取余法作为实例

3.哈希表的应用

1. 使用哈希表进行快速的查找，哈希表因为特殊的结构，所以查找速度很快
2. 在web开发中可以作为缓存来减少对数据库的压力，可以先从数据库中取出数据存入哈希表，之后的查找操作可以通过查找哈希表来完成。
   

4.代码实现

/**
 * @Author: LySong
 * @Date: 2020/3/12 17:55
 */
public class HashTableDemo {
    public static void main(String[] args) {
        //创建哈希表
        HashTable hashTable = new HashTable(7);
        //写一个简单的菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("add: 添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("delete: 删除雇员");
            System.out.println("exit: 退出系统");
            key = scanner.next();
            switch (key){
                case "add":
                    System.out.println("输入id");
                    int id = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建雇员
                    Emp emp = new Emp(id, name);
                    hashTable.add(emp);
                    break;
                case "list":
                    hashTable.list();
                    break;
                case "find":
                    System.out.println("输入id");
                    hashTable.findEmpById(scanner.nextInt());
                    break;
                case "delete":
                    System.out.println("输入id");
                    hashTable.deleteEmpById(scanner.nextInt());
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                    break;
                default:
                    break;
            }
        }

    }
}

/**
 * 创建HashTable 管理多条链表
 */
class HashTable{
    /**
     * 表示每条链表
     */
    private EmpLinkedList[] empLinkedLists;
    /**
     * 表示共有多少条链表
     */
    private int size;
    public HashTable(int size) {
        //对size赋值
        this.size = size;
        //初始化empLinkedLists
        empLinkedLists = new EmpLinkedList[size];
        //不要忘了 分别初始化，每一条链表
        for (int i = 0; i < size; i++) {
            empLinkedLists[i] = new EmpLinkedList();
        }
    }

    /**
     * 添加雇员
     * @param emp
     */
    public void add(Emp emp){
        //根据员工的id，得到该员工应该加入到哪条链表
        int empLinkedListNO = hashFun(emp.id);
        //将emp加入到对应的链表中
        empLinkedLists[empLinkedListNO].add(emp);
    }

    /**
     * 遍历哈希表
     */
    public void list(){
        for (int i = 0; i < size; i++) {
            empLinkedLists[i].list(i);
        }
    }

    /**
     * 根据id查找雇员
     * @param id 雇员id
     */
    public void findEmpById(int id){
        //使用散列函数确定到哪条链表查找
        int empLinkedListNO = hashFun(id);
        Emp emp = empLinkedLists[empLinkedListNO].findEmpById(id);
        if(emp != null){
            System.out.println("在第"+ empLinkedListNO + "链表中找到该雇员");
            System.out.println(emp.toString());
        }else {
            System.out.println("没有找到该雇员");
        }
    }

    /**
     * 根据id删除雇员
     * @param id 雇员id
     */
    public void deleteEmpById(int id){
        //使用散列函数确定到哪条链表查找
        int empLinkedListNO = hashFun(id);
        empLinkedLists[empLinkedListNO].deleteEmpById(id);
    }

    /**
     * 散列函数
     * @param id 员工的id
     * @return
     */
    public int hashFun(int id){
        return id % size;
    }
}


/**
 * 雇员
 */
class Emp{
    public int id;
    public String name;
    /**
     * 默认为空
     */
    public Emp next;
    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }

    /**
     * toSting方法
     */
    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

/**
 * 创建EmpLinkedList链表
 */
class EmpLinkedList{
    /**
     * 头指针，执行第一个Emp，因此我们这个链表的head指向第一个Emp
     */
    private Emp head;

    /**
     * 添加雇员到链表
     * 1.假定，当添加雇员时，id自增，id分配总是从小到大
     *   因此我们将雇员直接介入到本链表的最后即可
     * @param emp
     */
    public void add(Emp emp){
        //如果添加第一个雇员
        if(head == null){
            head = emp;
            return;
        }
        //如果不是第一个雇员，则使用一个辅助指针帮助定位到最后
        Emp curEmp = head;
        //判断链表是否到最后
        while (curEmp.next == null){
            //说明链表到最后
            curEmp.next = emp;
        }
        //退出时直接将emp加入链表
        curEmp.next = emp;
    }

    /**
     * 遍历链表的雇员信息
     */
    public void list(int no){
        //当head为空时，说明链表没有数据
        if(head == null){
            System.out.println("第"+ no +"链表为空");
            return;
        }
        System.out.print("第"+ no +"链表的信息为");
        //定义辅助指针进行遍历
        Emp curEmp = head;
        while (curEmp != null){
            //打印数据
            System.out.printf("=> id=%d name=%s\t",curEmp.id,curEmp.name);
            System.out.println();
            //继续后移遍历
            curEmp = curEmp.next;
        }

    }

    /**
     * 根据id查找雇员
     * @param id 雇员id
     * @return
     */
    public Emp findEmpById(int id){
        //判断链表是否为空
        if(head == null){
            System.out.println("链表为空");
            return null;
        }
        //辅助指针
        Emp curEmp = head;
        while (curEmp != null){
            if(curEmp.id == id){
                return curEmp;
            }
            curEmp = curEmp.next;
        }
        return null;
    }

    /**
     * 根据id删除雇员
     * @param id 雇员id
     */
    public void deleteEmpById(int id){
        //判断链表是否为空
        if(head == null){
            System.out.println("链表为空");
            return;
        }
        if(head.id == id){
            if(head.next == null){
                head = null;
                System.out.println("删除成功");
            } else {
                head = head.next;
            }
            return;
        }
        //辅助指针
        Emp curEmp = head;
        while (curEmp != null){
            if(curEmp.next.id == id){
                curEmp.next = curEmp.next.next;
                System.out.println("删除成功");
                return;
            }
            curEmp = curEmp.next;
        }
        System.out.println("没有找到该雇员");
    }
}