哈希表---依据尚硅谷的题目讲解

哈希表：也叫散列表，java集合的底层。通过将关键码值(key value)映射到表中的位置来访问记录，以加快访问速度，这个映射函数叫散列函数，存放记录的数组叫散列表。

在web开发时，经常访问数据库拿到值来返回客户端，但对于经常要进行查询的值会增加到Redis或Memcache等缓存中，来提高访问效率。但在过去没有缓存产品，就会使用哈希表(数组+链表、数组+二叉树) 来添加一层或多层缓冲。

尚硅谷的数据结构下的题目：

1. 创建雇员的实体类：

//表示雇员信息
class Emp{
    public int id;
    public String name;
    public Emp next;

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

2. 创建链表用来存储雇员信息：

//链表
class EmployeeLinkedList{
    //每一个链表都有一个头指针，指向当前链表的第一个元素
    private Emp head;

    public void add(Emp emp){
        //添加的是第一个元素
        if (head == null){
            head = emp;
            return;
        }
        //不是，则找到最后一个元素，让它指向添加的元素。
        Emp current = head;
        while(current != null){
            current = current.next;
        }
        current.next = emp;
    }

    public void list(){
        //遍历链表
        Emp cur = head;
        if (head == null){
            System.out.println("当前链表为空");
            return;
        }

        System.out.println("当前链表信息为");
        while(true){
            System.out.printf("--> id=%d name=%s\t",cur.id,cur.name);
            if (cur.next == null){
                break;
            }
            cur = cur.next;
        }
        System.out.println();
    }

    public Emp findEmpByid(int id){
        if (head == null){
            System.out.println("链表空");
            return null;
        }
        Emp cur = head;
        while (true){
            if (cur.id == id){
                return cur;
            }
            if (cur.next == null){
                cur = null;
                break;
            }
            cur = cur.next;
        }
        return cur;
    }

    //删除元素
    public String delEmp(int id){
        if (head == null){
            String str = "哈希表为空，确认要删除的值是否存在";
        }
        while (head.next != null){
            if (head.next.id == id){
                //下一个元素就是我们要删除的元素
                head.next = head.next.next;
                return "删除成功";
            }
            head = head.next;
        }
        return "确认要删除的值是否存在";
    }
}

4. 哈希表：使用散列存储的方式

1. 初始化，依据传入的值来初始化链表，注意要创建对象。

2. 添加雇员信息到哈希表中：1.首先在哈希表调用哈希函数产生值。2.将产生的值作为下标找到链表，存入链表中。

3. 删除雇员信息：1.首先在哈希表调用哈希函数产生值。2.将产生的值作为下标找到链表，将要删除的id比对删除。

4. 依据id找到某一雇员：1.首先在哈希表调用哈希函数产生值。2.将产生的值作为下标找到链表，将id传入找到相同id雇员。

5. 展示雇员信息：循环遍历展示每条链表

//哈希表
class HashTab{
    //数组，用来存放链表
    private EmployeeLinkedList[] employeeLinkedLists;
    private int size;

    //构造函数，初始化数组大小，并创建对应的链表
    public HashTab(int size){
        this.size = size;
        employeeLinkedLists = new EmployeeLinkedList[size];
        for (int i = 0; i < size; i++) {
            employeeLinkedLists[i] = new EmployeeLinkedList();
        }
    }

    public void add(Emp emp){
        //添加用户前使用hash函数来判断应该存储到哪一个链表中
        int empNo = hashfun(emp.id);
        employeeLinkedLists[empNo].add(emp);
    }

    //哈希函数，决定哪个雇员对应到哪一根链表
    public int hashfun(int id){
        return id % size;
    }

    public void list(){
        for (int i = 0; i < size; i++) {
            employeeLinkedLists[i].list();
        }
    }

    public void del(int id){
        int empNo = hashfun(id);
        String str = employeeLinkedLists[empNo].delEmp(id);
        System.out.println(str);
    }

    public void FindEmpByid(int id){
        int empNo = hashfun(id);
        Emp emp = employeeLinkedLists[empNo].findEmpByid(id);
        if (emp != null){
            System.out.println("在第"+(empNo+1)+"条链表中找到");
        }else {
            System.out.println("在哈希表中没有找到该雇员");
        }
    }
}