数据结构——HashTable

基本介绍

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

哈希表管理学生信息概图

示例代码

• 学生信息类

@Data
public class Student {
    private int id;
    private String name;
    private String sex;
    private String address;
    private Student next;

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

    public Student(int id, String name, String sex, String address) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.address = address;
    }
}

• 学生链表类，这里都是简单的链表操作，其余操作详见数据结构——单向链表

public class StudentLinkedList {

    /*头节点*/
    private Student head;

    /**
     * 添加节点：整个过程默认将节点添加到链表的最后
     *
     * @param student
     */
    public void add(Student student) {
        if (student == null) {
            return;
        }
        /*如果链表为空，直接将节点添加到链表的头节点即可*/
        if (isEmpty()) {
            head = student;
            return;
        }
        Student temp = head;
        while (true) {
            if (temp.getNext() == null) {
                break;
            }
            temp = temp.getNext();
        }
        temp.setNext(student);
    }

    /**
     * 显示链表下的元素
     */
    public void show() {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        Student temp = head;
        while (true) {
            System.out.println(temp);
            if (temp.getNext() == null) {
                break;
            }
            temp = temp.getNext();
        }
    }

    /**
     * 判断链表是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return head == null;
    }

    /**
     * 根据编号获取链表节点信息
     *
     * @param no
     * @return
     */
    public Student findById(int no) {
        if (isEmpty()) {
            System.out.println("当前链表为空");
            return null;
        }
        Student temp = head;
        while (true) {
            if (temp.getId() == no) {
                break;
            }
            if (temp.getNext() == null) {
                temp = null;
                break;
            }
            temp = temp.getNext();
        }
        return temp;
    }

    /**
     * 根据编号删除编号对应节点
     *
     * @param id
     */
    public void remove(int id) {
        if (isEmpty()) {
            return;
        }
        /*如果头节点即为待删除的节点，直接修改头节点即可*/
        if (head.getId() == id) {
            head = head.getNext();
            return;
        }
        Student temp = head;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.getNext().getId() == id) {
                temp.setNext(temp.getNext().getNext());
                break;
            }
            temp = temp.getNext();
        }

    }

}

• HashTable类

public class HashTable {
    private StudentLinkedList[] studentLinkedListArray;
    /*指定HashTable的默认长度*/
    private int size = 16;

    public HashTable() {
        studentLinkedListArray = new StudentLinkedList[size];
        innitHashTable(studentLinkedListArray);
    }

    public HashTable(int size) {
        this.size = size;
        studentLinkedListArray = new StudentLinkedList[size];
        innitHashTable(studentLinkedListArray);
    }

    public void add(Student student) {
        if (student == null) {
            return;
        }
        studentLinkedListArray[hashFun(student.getId())].add(student);
    }

    public Student findById(int no) {
        return studentLinkedListArray[hashFun(no)].findById(no);
    }

    public void removeById(int no) {
        studentLinkedListArray[hashFun(no)].remove(no);
    }

    /**
     * 初始化hashTable链表的数值的第一个元素(head节点)，不然会报NPE
     *
     * @param studentLinkedListArray
     */
    private void innitHashTable(StudentLinkedList[] studentLinkedListArray) {
        if (studentLinkedListArray == null || studentLinkedListArray.length == 0) {
            return;
        }
        for (int i = 0; i < studentLinkedListArray.length; i++) {
            studentLinkedListArray[i] = new StudentLinkedList();
        }
    }

    public void show() {
        System.out.println("链表下的元素为：");
        for (int i = 0; i < size; i++) {
            System.out.printf("第 %d 条链表 =>:", i);
            studentLinkedListArray[i].show();
        }
    }

    /**
     * 获取散列数值,这里的计算函数很简单，真正的HashTable哈希值的计算可能会很复杂，出现哈希碰撞的概率基本为0
     *
     * @param id
     * @return
     */
    private int hashFun(int id) {
        return id % size;
    }
}