哈希表

哈希表：

哈希表又称散列表，结构为数组加链表，通过计算数据的哈希值能够准确知道这个数据在哪条链表上，加快查找速度（自己写的，可能不太准确）。

例子：

有一个公司,当有新的员工来报道时,要求将该员工的信息(编号,名字)加入，然后可以对这个员工进行增删改查，要求使用哈希表。

代码：

import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Scanner;

public class HashTableTest {
    public static void main(String[] args) {
        //创建哈希表
        HashTable hashTab = new HashTable(7);
        //写一个简单的菜单
        String key = "";
        Scanner scanner = new Scanner(System.in);
        while(true) {
            System.out.println("add:  添加雇员");
            System.out.println("delete:  删除雇员");
            System.out.println("update:  修改雇员");
            System.out.println("find: 查找雇员");
            System.out.println("list: 显示雇员");
            System.out.println("exit: 退出系统");

            key = scanner.next();
            switch (key) {
                case "add":
                    System.out.println("输入编号");
                    int no = scanner.nextInt();
                    System.out.println("输入名字");
                    String name = scanner.next();
                    //创建 雇员
                    EmpNode emp = new EmpNode(no, name);
                    boolean addBoo = hashTab.add(emp);
                    if (addBoo) {
                        System.out.println("~~~添加成功~~~");
                    } else {
                        System.out.println("~~~添加失败~~~");
                    }
                    break;
                case "delete":
                    System.out.println("输入编号");
                    no = scanner.nextInt();
                    boolean deleteBoo = hashTab.delete(no);
                    if (deleteBoo) {
                        System.out.println("~~~删除成功~~~");
                    } else {
                        System.out.println("~~~删除失败~~~");
                    }
                    break;
                case "update":
                    System.out.println("输入编号");
                    no = scanner.nextInt();
                    System.out.println("输入名字");
                    name = scanner.next();
                    //创建 雇员
                    emp = new EmpNode(no, name);
                    boolean updateBoo = hashTab.update(emp);
                    if (updateBoo) {
                        System.out.println("~~~更新成功~~~");
                    } else {
                        System.out.println("~~~更新失败~~~");
                    }
                    break;
                case "find":
                    System.out.println("请输入要查找的编号");
                    no = scanner.nextInt();
                    EmpNode empNode = hashTab.find(no);
                    if (empNode == null) {
                        System.out.println("~~~没有找到~~~");
                    } else {
                        System.out.println(empNode);
                    }
                    break;
                case "list":
                    hashTab.list();
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }
    }
}

/**
 * 员工节点
 */
@Data
@NoArgsConstructor
class EmpNode {

    /**
     * 员工编号
     */
    private int empNo;

    /**
     * 员工名称
     */
    private String empName;

    private EmpNode next;

    public EmpNode(int empNo, String empName) {
        this.empNo = empNo;
        this.empName = empName;
    }

    @Override
    public String toString() {
        return "EmpNode{" +
                "empNo=" + empNo +
                ", empName=" + empName +
                '}';
    }
}

/**
 * 单链表
 */
@NoArgsConstructor
class EmpLinkedList {

    /**
     * 头节点
     */
    private EmpNode headNode;

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty() {
        return headNode == null;
    }

    /**
     * 添加
     * @param empNode
     * @return
     */
    public boolean add(EmpNode empNode) {
        if (isEmpty()) {
            //添加第一个元素
            headNode = empNode;
            return true;
        }
        //按编号顺序添加
        if (empNode.getEmpNo() < headNode.getEmpNo()) {
            //新的节点作为头节点
            empNode.setNext(headNode);
            headNode = empNode;
            return true;
        } else if (empNode.getEmpNo() == headNode.getEmpNo()) {
            return false;
        }
        EmpNode temp = headNode;
        while (temp.getNext() != null) {
            if (empNode.getEmpNo() < temp.getNext().getEmpNo()) {
                empNode.setNext(temp.getNext());
                temp.setNext(empNode);
                return true;
            } else if (empNode.getEmpNo() == temp.getNext().getEmpNo()) {
                return false;
            }
            temp = temp.getNext();
        }
        temp.setNext(empNode);
        return true;
    }

    /**
     * 删除
     * @param empNo
     * @return
     */
    public boolean delete(int empNo) {
        if (isEmpty()) {
            return false;
        }

        if (headNode.getEmpNo() == empNo) {
            //删除当前的头节点
            headNode = headNode.getNext();
            return true;
        } else if (headNode.getEmpNo() > empNo) {
            return false;
        }
        EmpNode temp = headNode;
        while (temp.getNext() != null) {
            if (temp.getNext().getEmpNo() == empNo) {
                temp.setNext(temp.getNext().getNext());
                return true;
            } else if (temp.getNext().getEmpNo() > empNo) {
                return false;
            }
            temp = temp.getNext();
        }
        return false;
    }

    /**
     * 更新
     * @param empNode
     * @return
     */
    public boolean update(EmpNode empNode) {
        if (isEmpty()) {
            return false;
        }
        EmpNode temp = headNode;
        while (temp != null) {
            if (temp.getEmpNo() == empNode.getEmpNo()) {
                temp.setEmpName(empNode.getEmpName());
                return true;
            } else if (temp.getEmpNo() > empNode.getEmpNo()) {
                return false;
            }
            temp = temp.getNext();
        }
        return false;
    }

    /**
     * 查找
     * @param empNo
     * @return
     */
    public EmpNode find(int empNo) {
        if (isEmpty()) {
            return null;
        }
        EmpNode temp = headNode;
        while (temp != null) {
            if (temp.getEmpNo() == empNo) {
                return temp;
            } else if (temp.getEmpNo() > empNo) {
                return null;
            }
            temp = temp.getNext();
        }
        return null;
    }

    @Override
    public String toString() {
        if (isEmpty()) {
            return "->链表为空";
        }
        EmpNode temp = headNode;
        StringBuilder strBu = new StringBuilder();
        while (temp != null) {
            strBu.append("->{no:" + temp.getEmpNo() + ",name:" + temp.getEmpName() + "}");
            temp = temp.getNext();
        }
        return strBu.toString();
    }
}

class HashTable {
    /**
     * 链表数组
     */
    private EmpLinkedList[] empLinkedListArr;

    /**
     * 链表数组的长度
     */
    private int size;

    public HashTable(int size) {
        this.size = size;
        empLinkedListArr = new EmpLinkedList[size];
        for (int i = 0; i < empLinkedListArr.length; i++) {
            empLinkedListArr[i] = new EmpLinkedList();
        }
    }

    /**
     * 计算哈希值
     * @param no
     * @return
     */
    private int hashValue(int no) {
        return no % size;
    }

    /**
     * 添加
     * @param empNode
     * @return
     */
    public boolean add(EmpNode empNode) {
        int hashValue = hashValue(empNode.getEmpNo());
        //根据哈希值来判断是落在哪条链表上
        return empLinkedListArr[hashValue].add(empNode);
    }

    /**
     * 删除
     * @param empNo
     * @return
     */
    public boolean delete(int empNo) {
        int hashValue = hashValue(empNo);
        //根据哈希值判断是在哪条链表上
        return empLinkedListArr[hashValue].delete(empNo);
    }

    /**
     * 更新
     * @param empNode
     * @return
     */
    public boolean update(EmpNode empNode) {
        int hashValue = hashValue(empNode.getEmpNo());
        //根据哈希值判断是在哪条链表上
        return empLinkedListArr[hashValue].update(empNode);
    }

    /**
     * 查找
     * @param empNo
     * @return
     */
    public EmpNode find(int empNo) {
        int hashValue = hashValue(empNo);
        //根据哈希值判断是在哪条链表上
        return empLinkedListArr[hashValue].find(empNo);
    }

    /**
     * 遍历
     */
    public void list() {
        for (int i = 0; i < empLinkedListArr.length; i++) {
            System.out.println("arr[" + i + "]: " + empLinkedListArr[i].toString());
        }
    }
}