哈希表基于数组和链表java数据结构篇

本章学习目录

• 页内目录
  一，哈希表的介绍
  二，哈希表的图解
  三，哈希表的链表部分
  四，哈希表的实现类
  五，结果测试与展示

一，哈希表的介绍

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

二，哈希表的图解

三，哈希表的链表部分

• 节点类

public class Emp {
    public int id;
    public String name;
    public Emp next;

    //构造方法
    public Emp(int id, String name) {
        this.id = id;
        this.name = name;
    }

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

• 链表实现类

public class EmpLinkedList {
    //定义头节点
    private Emp head;

    //添加雇员方法
    public void add(Emp emp){
        //二种情况：1.链表为空；2.链表有节点
        //1.链表为空
        if (head==null){
            head=emp;
            return;
        }
        //2.链表存在节点
        //定义一个辅助指针，找到链表的最后位置，再进行插入
        Emp temp=head;
        //通过while循环，找到最后
        while (temp.next!=null){
            temp=temp.next;
        }//循环退出时temp即为最后的节点
        //将新添的节点赋值于最后节点的下一个
        temp.next=emp;
    }

    //遍历链表方法
    public void list(){
        if (head==null){
            System.out.println("该链表为空");
            return;
        }
        //辅助节点
        Emp temp=head;
        //通过while循环遍历
        System.out.print("该链表信息为：");
        while (temp!=null){
            System.out.print("==>"+temp.id);
            temp=temp.next;
        }
        System.out.println();
    }
    
    //根据id查找方法
    public Emp findByid(int id){
        //三种情况：1.表为空；2.找到；3.遍历完了，还未找到
        //返回两种情况：1.null：没有找到；2.找到！返回该节点
        //1表为空
        if (head==null){
            return null;
        }
        //2找到
        //定义辅助节点
        Emp temp=head;
        //while循环遍历
        while (temp.id!=id){
            temp=temp.next;
            //遍历完了，还未找到
            if (temp==null){
                return null;
            }
        }
        return temp;
    }
}

四，哈希表的实现类

public class HashTab {
    //创建一个链表的数组
    EmpLinkedList[] empLinkedListArr;
    private int size;

    //构造方法，初始化数组大小
    public HashTab(int size) {
        this.size = size;
        empLinkedListArr=new EmpLinkedList[size];
        //很重要，初始化每个链表
        for (int i = 0; i <size ; i++) {
            empLinkedListArr[i]=new EmpLinkedList();
        }
    }

    //添加节点
    public void add(Emp emp){
        //确定添加到哪个链表，这里写一个散列函数hashFun
        int Arrnum=hashFun(emp.id);
        //将节点添加到对应的链表中
        empLinkedListArr[Arrnum].add(emp);
    }
    //散列函数
    private int hashFun(int id){
        return id%size;
    }

    //遍历哈希表
    public void list(){
        for (int i = 0; i <size ; i++) {
            empLinkedListArr[i].list();
        }
    }
    //查找
    public void findEmpBYId(int id){
        //得到在数组中的位置
        int empArr = hashFun(id);
        //获得该节点
        Emp byid = empLinkedListArr[empArr].findByid(id);
        //判断
        if (byid!=null){
            System.out.println(byid.toString());
        }else {
            System.out.println("没有找到该节点");
        }
    }
}

五，结果测试展示

        HashTab hashTab = new HashTab(7);
        Emp emp1=new Emp(7,"aa");
        Emp emp5=new Emp(14,"aa");
        Emp emp2=new Emp(8,"bb");
        Emp emp3=new Emp(9,"cc");
        Emp emp4=new Emp(10,"cc");
        hashTab.add(emp1);
        hashTab.add(emp2);
        hashTab.add(emp3);
        hashTab.add(emp4);
        hashTab.add(emp5);
        hashTab.list();
        System.out.println("-----------");
        hashTab.findEmpBYId(11);
        hashTab.findEmpBYId(10);
        hashTab.findEmpBYId(9);
        hashTab.findEmpBYId(8);
        hashTab.findEmpBYId(7);