数据结构之哈希表

哈希表

• 难点：“键”通过哈希函数得到的“索引”分布越均匀越好(对于不同数据可以通过转换、技巧和方法等转换为int类型的索引)。
• 特点：一致性。如果 a == b ,则 hash(a) == hash(b)即值相等的hash一定相等，但是hash值相等的，值不一定相等。
• 注意：hashCode(key)可能为负数，为了解决这个问题，需要进行按位与运算。即hashCode(k1) & 0x7fffffff
• 版本：Java中哈希表的实现，Java8之前，每一个位置对应一个链表，从Java8开始，当哈希冲突达到一定程度时，每个位置自动从链表转为红黑树。
• 时间复杂度：N为存储的元素个数(即size)，M为数组的长度，当每个地址是链表O(N/M)，每个地址是红黑树O(log(N/M))
• 动态扩容：平均每个地址承载的元素多过一定程度，即扩容(N/M>=upperTol)；平均每个地址承载的元素少过一定程度，即缩容(N/M<=loweTol)

自定义hash表的二叉树结构

package com.company.hash;

import java.util.*;

/**
 * 自定义二分搜索树
 * 实现比较器，Comparable即该类支持排序
 *
 * @param <E> 泛型
 * @Author: wenhua
 * @CreateTime: 2023-01-18  11:21
 */
public class SearchTree<E extends Comparable<E>> {

    /**
     * 自定义二分搜索树结点
     * 为了确保数据的可比性，所以泛型需要继承Comparable类
     *
     * @Author: wenhua
     * @CreateTime: 2023-01-08  13:31
     */
    public class Node<E extends Comparable<E>> {

        E ele;// 节点数据
        Node left;
        Node right;// 左孩子和右孩子

        public Node() {
            this(null);
        }

        public Node(E ele) {
            this.ele = ele;
            left = null;
            right = null;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "ele=" + ele +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }

    private Node root;
    private int size;

    public SearchTree() {
        root = null;
        size = 0;
    }

    /**
     * 判断二分搜索树是否为空
     *
     * @return 返回布尔值
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 二分搜索树的长度
     *
     * @return 返回int值
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 添加二分搜索树结点
     *
     * @param ele 添加元素
     */
    public void add(E ele) {
        root = add(root, ele);
    }

    /**
     * 递归添加二分搜索树结点
     *
     * @param head 以当前结点为根结点
     * @param ele 添加元素
     * @return 返回添加后的根结点
     */
    private Node add(Node head, E ele) {
        // 递归结束条件
        if (head == null) {
            Node node = new Node(ele);
            size++;
            return node;
        }
        // 变成重复的同一问题
        if (head.ele.compareTo(ele) > 0) {
            head.left = add(head.left, ele);
        } else if (head.ele.compareTo(ele) < 0) {
            head.right = add(head.right, ele);
        }
        return head;// 和节点元素相等时
    }

    /**
     * 判断该结点是否存在
     *
     * @param ele 指定元素
     * @return 返回布尔值
     */
    public boolean isContain(E ele) {
        return isContain(root, ele);
    }

    /**
     * 递归判断该结点是否存在于二分搜索树中
     * 即就是查找该结点
     *
     * @param node 以当前结点为根结点
     * @param ele 判断指定元素
     * @return 返回布尔值
     */
    private boolean isContain(Node node, E ele) {
        // 最糟糕情况，即遍历完二分搜索树该结点不存在
        if (node == null) {
            return false;
        }
        if (node.ele.compareTo(ele) > 0) {// 当前节点数据大于ele，则在左子树中查找
            return isContain(node.left, ele);
        } else if (node.ele.compareTo(ele) < 0) { // 当前节点数据小于ele，则在右子树中查找
            return isContain(node.right, ele);
        }
        return true;
    }

    /**
     * 根据二分搜索树的性质获取最小结点数据
     *
     * @return 返回最小结点元素
     */
    public E getMinEle() {
        if (isEmpty())
            return null;
        Node temp = root;
        while (temp.left != null) {
            temp = temp.left;
        }
        return (E) temp.ele;
    }

    /**
     * 通过递归获得二分搜索树的最小结点数据
     *
     * @return 返回最小结点元素
     */
    public E getMinElement() {
        if (isEmpty())
            return null;
        return (E) getMinNode(root).ele;
    }

    private Node getMinNode(Node node) {
        if (node.left == null)
            return node;
        return getMinNode(node.left);
    }

    /**
     * 移除最小结点
     *
     * @return 返回最小结点元素
     */
    public E removeMinNode() {
        if (isEmpty())
            return null;
        E ele = getMinEle();
        root = removeMinNode(root);
        return ele;
    }

    /**
     * 删除以node为根结点的最小结点
     *
     * @param node 移除结点
     * @return 返回移除后的结点
     */
    private Node removeMinNode(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            size--;
            node.right = null;
            return rightNode;
        }
        node.left = removeMinNode(node.left);
        return node;
    }

    /**
     * 移除指定结点
     * 1、判断指定结点是否存在
     * 2、找到指定删除的结点(递归，删除后的子树需要返回)
     * 3、判断其左右子树情况
     *  3.1只有右子树或只有左子树时，直接换为子树结点
     *  3.2无子树时直接删除
     *  3.3左右子树同时存在，找到右子树最小结点与之替换
     *
     * @param ele 移除元素
     */
    public void remove(E ele) {
        root = remove(root, ele);
    }

    /**
     * 递归移除指定元素
     *
     * @param node 以当前结点为根结点
     * @param ele  移除元素
     * @return 返回移除后结点
     */
    private Node remove(Node node, E ele) {
        // 如果当前结点为空，则不存在该结点，返回空
        if (node == null) {
            return null;
        }
        // 查找指定元素的结点
        if (node.ele.compareTo(ele) > 0) {// 当前结点数据大于查找结点数据，向左子树查找
            // 将删除指定元素结点后的树结构赋值给当前结点的左子树
            node.left = remove(node.left, ele);
            // 返回当前结点，与前面结点连接
            return node;
        } else if (node.ele.compareTo(ele) < 0) {// 当前结点数据小于查找结点数据，向右子树查找
            // 将删除指定元素结点后的树结构赋值给当前结点的右子树
            node.right = remove(node.right, ele);
            // 返回当前结点，与前面结点连接
            return node;
        } else {// 找到指定元素的结点
            if (node.left == null) {// 左子树为空时，直接将右子树赋予当前要删除的结点
                // 将当前结点的右子树赋值给临时结点变量
                Node rightNode = node.right;
                // 树的结点数量减1
                size--;
                // 将当前结点的右子树置空
                node.right = null;
                // 返回临时结点变量，与其他结点连接
                return rightNode;
            } else if (node.right == null) {// 右子树为空时，直接将左子树赋予当前要删除的结点
                Node leftNode = node.left;
                // 树的结点数量减1
                size--;
                // 将当前结点的左子树置空
                node.left = null;
                // 返回临时结点变量，与其他结点连接
                return leftNode;
            } else {
                // 以当前结点为根，找到当前结点右子树中最小的结点
                Node tempNode = getMinNode(node.right);
                // 以当前结点为根，删除右子树中的最小结点，并返回删除后的根结点
                Node delNode = removeMinNode(node.right);
                // 将右子树中的最小结点删除后的树结构赋值给最小结点的右子树
                tempNode.right = delNode;
                // 树的结点数量减1
                size--;
                // 当前结点的左子树赋值给最小结点的左子树
                tempNode.left = node.left;
                // 将当前结点的左右子树置空
                node.left = node.right = null;
                // 返回临时结点变量，与其他结点连接
                return tempNode;
            }
        }
    }

    /**
     * 获取二叉树所有结点的数据
     *
     * @return 返回字符串类型
     */
    public String getString() {
        List<E> list = new ArrayList<>();
        getList(root, list);
        StringBuffer sbf = new StringBuffer();
        for (E e : list) {
            sbf.append(e + ",");
        }
        return sbf.toString();
    }

    /**
     * 递归中序遍历获取二叉树所有节点的元素
     *
     * @param node 以当前结点为根结点
     * @param list 用于存储结点元素
     */
    private void getList(Node<E> node, List<E> list) {
        // 判断当前结点是否为空
        if (node == null) {
            return;
        }
        //1、遍历左子树
        getList(node.left, list);
        //2、访问该结点
        list.add(node.ele);
        //3、遍历右子树
        getList(node.right, list);
    }

    /**
     * 便于外界获取二叉树所有节点的元素
     *
     * @param list 用于存储结点元素
     */
    public void getList(List<E> list) {
        getList(root, list);
    }

}

自定义hash表结构

package com.company.hash;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义hash表
 *
 * @param <E> 泛型
 * @Author: wenhua
 * @CreateTime: 2023-01-18  11:01
 */
public class HashTable<E extends Comparable<E>> {

    private static final int UPPER_TOL = 5;
    private static final int LOWER_TOL = 2;

    private SearchTree<E>[] hashTable;// 只是声明为数组的数据结构而不是对象
    private int size;// 存储元素个数
    private int M;// hash函数表空间大小(素数)

    public HashTable() {
        this(97);
    }

    /**
     * 有参构造函数
     *
     * @param M
     */
    public HashTable(int M) {
        this.M = M;
        this.hashTable = new SearchTree[M];
        for (int i = 0; i < M; i++) {
            hashTable[i] = new SearchTree<>();
        }
    }

    /**
     * 获取大于新容量的最小素质
     *
     * @param capacity 容量
     * @return 返回int值
     */
    public int getPrime(int capacity) {
        int num = capacity;
        if (num <= 3) {
            return num > 1 ? 3 : 2;
        }
        int sqrt = (int) Math.sqrt(num);
        while (true) {
            boolean result = true;
            // 内层循环负责制造每个数的除数
            for (int n = 2; n <= sqrt; n++) {
                if (num % n == 0) {
                    num++;
                    result = false;
                    break;
                }
            }
            if (result) {
                return num;
            }
        }
    }

    /**
     * 获取该元素的hash值
     *
     * @param ele 键
     * @return 返回int值
     */
    private int hash(E ele) {
        return (ele.hashCode() & 0x7fffffff) % this.M;// & 0x7fffffff是因为hashCode转化后可能为负数
    }

    /**
     * 判断是否为空
     *
     * @return 返回布尔值
     */
    public boolean isEmpty() {
        return this.size == 0;
    }

    /**
     * 判断哈希表中是否存在该元素
     * @param ele 指定元素
     * @return 返回布尔值
     */
    public boolean isContain(E ele){
        return hashTable[hash(ele)].isContain(ele);
    }

    /**
     * 获取元素个数
     *
     * @return 返回int值
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 添加元素
     *
     * @param ele 添加元素
     */
    public void add(E ele) {
        // 通过添加值的hash值，锁定在hash表中对应的二叉搜索树
        SearchTree searchTrees = hashTable[hash(ele)];
        // 如果不存在，则进行添加操作
        if (!searchTrees.isContain(ele)) {
            searchTrees.add(ele);
            size++;
            if (size/M > UPPER_TOL){
                reSize(M*UPPER_TOL);
            }
        }
    }

    /**
     * 扩容，缩容操作
     *
     * @param newCapacity 容量
     */
    private void reSize(int newCapacity) {
        // 注意当数组容量小于97时，就没必要缩容了
        if (newCapacity < 97) {
            return;
        }
        int oldM = this.M;
        // 获取新数组对象的容量
        this.M = getPrime(newCapacity);
        // 创建新数组对象
        SearchTree[] newHashTable = new SearchTree[M];
        // 对新数组对象进行初始化
        for (int i = 0; i < M; i++) {
            newHashTable[i] = new SearchTree<>();
        }
        // 将原始数组对象中的数据进行转移
        for (int i = 0; i < oldM; i++) {
            SearchTree searchTree = hashTable[i];
            List<E> list = new ArrayList<>();
            searchTree.getList(list);
            for (E ele : list) {
                newHashTable[hash(ele)].add(ele);
            }
        }
        // 将新数组对象赋值给原来的数组对象
        hashTable = newHashTable;
    }

    /**
     * 移除元素
     *
     * @param ele 移除元素
     */
    public void remove(E ele) {
        // 通过添加值的hash值，锁定在hash表中对应的二叉搜索树
        SearchTree searchTrees = hashTable[hash(ele)];
        // 如果存在，则进行删除操作
        if (searchTrees.isContain(ele)) {
            searchTrees.remove(ele);
            size--;
            if (size/M < LOWER_TOL){
                reSize(M/LOWER_TOL);
            }
        }
    }

    /**
     * 获取哈希表中所有元素
     *
     * @return 返回字符串类型
     */
    @Override
    public String toString() {
        StringBuffer sbf = new StringBuffer();
        sbf.append("{");
        for (int i = 0; i < hashTable.length; i++) {
            if (!hashTable[i].isEmpty()) {
                SearchTree searchTree = hashTable[i];
                sbf.append(searchTree.getString());
            }
        }
        int index = sbf.lastIndexOf(",");
        return sbf.toString().substring(0,index)+"}";
    }
}

测试

package com.company.hash;

/**
 * @Author: wenhua
 * @CreateTime: 2023-01-17  11:36
 */
public class Main {

    public static void main(String[] args) {
        HashTable<Integer> hashTable = new HashTable();
        hashTable.add(12);
        hashTable.add(15);
        System.out.println("哈希表中有:"+hashTable.getSize()+"个元素。哈希表中的元素分别是:"+hashTable);
        hashTable.remove(15);
        System.out.println("哈希表中有:"+hashTable.getSize()+"个元素。哈希表中的元素分别是:"+hashTable);
        // System.out.println(hashTable.getPrime(102));
        System.out.println("哈希表中是否存元素11:"+hashTable.isContain(11));
    }
}

测试结果

哈希表中有:2个元素。哈希表中的元素分别是:{12,15}
哈希表中有:1个元素。哈希表中的元素分别是:{12}
哈希表中是否存元素11:false