韩顺平数据结构哈希表笔记

哈希表相当于是缓冲区，不借助数据库完成数据库功能

 

 思路分析：

相当于是做做出一个链表数组

数组中的每一个元素都对应一条链表

一条链表上有多个雇员的信息（通过取模法实现）----> 散列函数

注意：在创造链表数组的时候也就是我们的哈希表时，通过构造器初始化时，不要忘记对数组中的每一个元素都要初始化，他不是简单的数组，数组中的每一个元素都对应了雇员链表

代码实现：

1、雇员信息类：

/**
 * 雇员信息
 */
class Emp {
    public int id;
    public String name;
    public Emp next;//默认为空

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

2、雇员链表：

主要在这里管理雇员链表的增删改查

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

    //添加雇员到链表
    //说明
    //1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
    //   因此我们将该雇员直接加入到本链表的最后即可
    public void add(Emp emp) {
        if (head == null) {
            head = emp;
            return;
        }
        //创建辅助指针
        Emp curEmp = head;
        while (true) {
            if (curEmp.next == null) {//找到
                break;
            }
            curEmp = curEmp.next;
        }
        curEmp = emp;
    }

    //打印
    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);
            if (curEmp.next == null) {
                break;
            }
            curEmp = curEmp.next;
        }
        System.out.println();
    }

    //根据编号查找雇员信息
    public Emp findEmpById(int id) {
        if (head == null) {
            System.out.println("链表空");
            return null;
        }
        Emp curEmp = head;
        while (true) {
            if (curEmp.id == id) {//找到
                break;
            }
            if (curEmp.next == null) {//没找到
                curEmp = null;
                break;
            }
            curEmp = curEmp.next;
        }

        return curEmp;
    }

    /**
     * 作业：删除指定id的雇员
     * @param id 雇员id
     */
    public void del(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;
        }
    }
}

3、哈希表：
主要是通过散列函数，确定员工是在链表数组中的第几个元素也就是第几条链表，从而调用雇员链表的方法进行增删改查

形象比喻的话，哈希表是宏观把控，真正进行增删改查的是雇员链表EmpLinkedList

/**
 * 创建哈希表
 */
class HashTab {
    private EmpLinkedList[] empLinkedList;
    private int size;

    public HashTab(int size) {
        this.size = size;
        empLinkedList = new EmpLinkedList[size];
        for (int i = 0; i < size; i++) {//重点，千万不要忘记创造链表
            empLinkedList[i] = new EmpLinkedList();
        }
    }

    //添加雇员
    public void add(Emp emp) {
        int empLinkedListNum = hashFun(emp.id);
        empLinkedList[empLinkedListNum].add(emp);
    }

    //遍历HashTab
    public void list() {
        for (int i = 0; i < size; i++) {
            empLinkedList[i].list(i);
        }
    }

    //根据id查找雇员
    public void findEmpById(int id) {
        int empLinkedListNum = hashFun(id);
        Emp emp = empLinkedList[empLinkedListNum].findEmpById(id);
        if (emp == null) {
            System.out.println("在哈希表中，没有找到该雇员~");
        } else {
            System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNum + 1), id);
        }
    }

    public void del(int id){
        int empLinkedListNum = hashFun(id);
        empLinkedList[empLinkedListNum].del(id);
    }

    //创造一个散列函数，找到我要放进去的链表是哪条
    //使用简单取模法
    public int hashFun(int id) {
        return id % size;
    }
}

4、测试类：
通过创建菜单进行测试：
 

package HashTab;

import java.util.Scanner;

/**
 * 哈希表
 * 需求：当有新员工报道时，录入该员工信息，输入id时可以查找到这个雇员的全部信息
 * @author : 爱编程的MG
 * 不用数据库
 */
public class HashTableDemo {
    public static void main(String[] args) {
        //测试
        HashTab hashTab = new HashTab(7);
        //创建菜单
        String key = "";
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("add:  添加雇员");
            System.out.println("list: 显示雇员");
            System.out.println("find: 查找雇员");
            System.out.println("del:  删除雇员");
            System.out.println("exit: 退出系统");

            key = sc.next();
            switch (key) {
                case "add":
                    System.out.println("输入id");
                    int id = sc.nextInt();
                    System.out.println("输入姓名");
                    String name = sc.next();
                    Emp emp = new Emp(id, name);
                    hashTab.add(emp);
                    break;
                case "list":
                    hashTab.list();
                    break;
                case "find":
                    System.out.println("请输入需要查找的ID");
                    id = sc.nextInt();
                    hashTab.findEmpById(id);
                    break;
                case "del":
                    System.out.println("请输入需要删除雇员的id");
                    id = sc.nextInt();
                    hashTab.del(id);
                    break;
                case "exit":
                    sc.close();
                    System.exit(0);
                default:
                    break;
            }
        }
    }
}