哈希表（散列表）

哈希表

散列表（Hash Table），又称哈希表，是一种数据结构，特点是：数据元素的关键字与其存储地址直接相关。
通过散列函数Addr=H（key）来建立之间的关系
例如 H（key）=key%13 —13为数组长度，但会出现冲突（两个元素在同一个地址）

解决冲突的方法

1、拉链法- - - 链表存储

但在链表存储中冲突越多，查找效率就越低
解决查找效率低的方法：
设计冲突更少的散列函数，使得平均查找时间变小。
常见的散列函数如下：
1）除留余数法— H(key)=key % p
散列表表长为m，取一个不大于m但最接近或等于m的质数p（取质数会使发生冲突的概率更小），但当元素是连续的时候，取质数反而不会减少冲突。—要结合实际

2）直接定址法— H(key)=key或 H(key)=a*key+b
直接定址/线性变化定址不会产生冲突，如果关键字不连续，会出现空位，导致存储空间的浪费。

3）数字分析法 — 选取数码分布较为均匀的若干位作为散列地址

4）平方取中法 — 取关键字的平方值的中间几位作为散列地址

2、开放定址法 - - - Hi = (H(key)+di) % m
1）线性探测法- - -di=0、1、2、3…、m-1 (m表示散列表表长，di为增量序列)
2）平方探测法- - -di=0^2 、1^2 、-1^2… 、k^2、、 -k^2 其中k<=m/2.
3）伪随机序列法- - -di是一个伪随机序列，如di=1、5、24、11…

注意：
采用“开放定址法”时，删除结点不能简单地将被删除结点为空，否则将截断在它之后填入的散列表的同义词结点的查找路径，可以做一个“删除标记”，进行逻辑删除。

3、再散列法 - - - 除了原始散列函数H(key)之外，多准备几个散列函数，当散列函数冲突时，用下一个散列函数计算一个新地址，直到不冲突为止： Hi=RHi(key) i=1，2，3…k

google上机题

有一个公司，当有新的员工报道时，要求将该员工的信息加入（id、名字）当输入该员工的id时，要求查找到该员工的所有信息。

要求：

不使用数据库、速度越快越好----故采用 哈希表

使用链表来实现哈希表，该链表不代表头（即：链表的第一个结点就存放雇员信息）

说明：
1、创建一个雇员的类（即：结点类）
2、创建一个EmpLinkedList类，表示链表类（添加结点、遍历、查找）
3、创建HashTable类，管理多条链表（运用散列函数—取模）哈希表类

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("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雇员");
                    id=scanner.nextInt();
                    hashTable.findEmpById(id);
                    break;
                case "exit":
                    scanner.close();
                    System.exit(0);
                default:
                    break;
            }
        }
    }

}

// 创建HashTable 管理多条链表（散列函数）
class HashTable{
    private EmpLinkedList[] empLinkedListArray;
    private int size;  // 表示共有多少条链表

    //构造器
    public HashTable(int size){
        this.size=size;
        // 初始化empLinkedListArray
        empLinkedListArray=new EmpLinkedList[size];
        // 这时不要忘记分别初始化每一条链表，不然每个链表时null，空指针异常
        for (int i=0;i<size;i++){
            empLinkedListArray[i]=new EmpLinkedList();
        }
    }

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

    // 遍历所有链表(遍历hashtable)
    public void list(){
        for (int i=0;i<size;i++){
            empLinkedListArray[i].list(i);
        }
    }

    //根据输入的id查找雇员
    public void findEmpById(int id){
        // 使用散列函数确定到哪条链表查找
        int empLinkedListNo=hashFun(id);

        Emp emp=empLinkedListArray[empLinkedListNo].findEmpById(id);
        if (emp!=null){
            System.out.printf("在第%d条链表中找到id=%d的雇员\n",(empLinkedListNo+1),id);
        }else {
            System.out.println("在哈希表中，没有找到该雇员");
        }
    }

    // 编写散列函数，使用一个简单取模法
    public int hashFun(int id){
        return id % size;
    }

}

//表示一个雇员
class Emp{
    public int id;
    public String name;
    public Emp next;  //next默认为null

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

// 创建EmpLinkedList，表示链表
class EmpLinkedList{
    // 头指针，执行第一个Emp，因此这个链表的head，是直接指向第一个Emp
    private Emp head; // 默认null

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

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

    // 根据id查找雇员
    // 如果查找到，就返回Emp，没有找到返回null
    public Emp findEmpById(int id){
        // 判断链表是否为空
        if (head==null){
            System.out.println("链表为空");
            return null;
        }
        // 辅助指针
        Emp temp=head;
        while (true){
            if (temp.id==id){ // 找到对应雇员
                break;  //这时temp指向查找的雇员
            }
            // 退出
            if (temp.next==null){  // 说明遍历当前链表没有找到该雇员
                temp=null;
                break;
            }
            temp=temp.next;  //后移
        }
        return temp;
    }

}