哈希表

【哈希表】

哈希表（HashTable）又称散列表，是根据关键码进行数据访问的一种数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

哈希表有多种实现结构：数组+链表，数组+二叉树。这里用数组+链表来实现哈希表

 

 数组+链表的形式，实际上就是一个链表数组。而添加数据时，只要根据填入数据的id，通过取特征码运算，获取一个特征码，添加链表节点的数组位置索引，就是这个特征码。其余操作与去前面所说的链表，数组几乎一样。下面的代码中，采用 单向-无头-普通类-循环 的链表来作为存储结构。

代码实现：

package cn.dataStructureAndAlgorithm.demo.HashTable;
import java.util.Scanner;

class Node{
    private int id;
    private String data;
    private Node next;

    public Node(int id, String data) {
        this.id = id;
        this.data = data;
    }

    public int getId() {
        return id;
    }

    public String getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", data='" + data + '\'' +
                '}';
    }
}
class LinkList{
    private Node root;

    public void add(Node node){//无序添加
        if (root==null){
            this.root=node;
            return;
        }
        Node temp=this.root;
        while (temp.getNext()!=null){//找到链表尾
            temp=temp.getNext();
        }
        temp.setNext(node);
    }
    public void show(){
        if (root==null){
            System.out.println("链表为空");
            return;
        }
        Node temp=root;
        while (temp!=null){
            System.out.print(" =>"+temp);
            temp=temp.getNext();
        }
        System.out.println();
    }
    public Node find(int id){
        if (root==null){
            return null;
        }
        Node temp=this.root;
        while (true){
            if (temp.getId()==id){//找到
                break;
            }
            if (temp.getNext()==null){//未找到
                temp=null;
                break;
            }
            temp=temp.getNext();
        }
        return  temp;
    }
    public void delete(int id){
        if (root==null){
            System.out.println("链表为空");
            return;
        }
        if (root.getId()==id){//删除根节点
            this.root=this.root.getNext();
        }else {//删除子节点
            Node temp=this.root;
            while (true) {
                if (temp.getNext() == null) {//未找到
                    System.out.println("未找到");
                    break;
                }
                if (temp.getNext().getId() == id) {//找到
                    temp.setNext(temp.getNext().getNext());
                    break;
                }
            }
        }
    }
}
class Hashtable{
    private int size;
    LinkList[] hashtable;

    public Hashtable(int size) {
        this.size = size;
        hashtable = new LinkList[size];//初始化链表数组
        for (int i=0;i<size;i++){//初始化链表数组中的每一个链表
            hashtable[i]=new LinkList();
        }
    }
    public int getHash(int id){//获取结点对应的哈希值
        return id%size;
    }
    public void add(Node node){
        int hashcode=getHash(node.getId());
        hashtable[hashcode].add(node);
    }
    public void show(){
        for (int i=0;i<size;i++){
            System.out.printf("第%d个链表：",i+1);
            hashtable[i].show();
        }
    }
    public void find(int id){
        int hashcode=getHash(id);
        Node findNode=hashtable[hashcode].find(id);
        if (findNode!=null){
            System.out.println("查询结果："+findNode);
        }else {
            System.out.println("找不到");
        }
    }
    public void delete(int id){
        int hashcode=getHash(id);
        hashtable[hashcode].delete(id);
    }

}
public class 哈希表_HashTable {
    public static void main(String[] args) {
        Hashtable hashtable=new Hashtable(7);
        Scanner scan=new Scanner(System.in);
        char key;
        int id;
        String data;
        Node newNode;
        while (true){
            System.out.println("a(add):添加数据");
            System.out.println("s(show):展示数据");
            System.out.println("f(find):操作数据");
            System.out.println("d(delete):删除数据");
            System.out.println("e(exit):退出程序");
            key=scan.next().charAt(0);
            switch (key){
                case 'a':
                    System.out.print("请输入id:");
                    id=scan.nextInt();
                    System.out.print("请输入data:");
                    data=scan.next();
                    newNode=new Node(id,data);
                    hashtable.add(newNode);
                    break;
                case 's':
                    hashtable.show();
                    break;
                case 'f':
                    System.out.print("请输入id:");
                    id=scan.nextInt();
                    hashtable.find(id);
                    break;
                case 'd':
                    System.out.print("请输入id:");
                    id=scan.nextInt();
                    hashtable.delete(id);
                    break;
                case 'e':
                    scan.close();
                    System.exit(0);//退出程序
                default:
                    break;
            }
        }
    }
}

a(add):添加数据
s(show):展示数据
f(find):操作数据
d(delete):删除数据
e(exit):退出程序
a
请输入id:9
请输入data:xiaoming
a(add):添加数据
s(show):展示数据
f(find):操作数据
d(delete):删除数据
e(exit):退出程序
s
第1个链表：链表为空
第2个链表：链表为空
第3个链表： =>Node{id=9, data='xiaoming'}
第4个链表：链表为空
第5个链表：链表为空
第6个链表：链表为空
第7个链表：链表为空
a(add):添加数据
s(show):展示数据
f(find):操作数据
d(delete):删除数据
e(exit):退出程序

 

【数据结构与算法整理总结目录 ：＞】<-- 宝藏在此（doge）