数据结构之哈希表-JAVA代码实现

于 2020-11-12 20:31:42 发布
阅读量236 收藏
点赞数
分类专栏： 数据结构 # HashMap 文章标签： 数据结构 hashmap 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haveaname/article/details/109655882
版权

数据结构之哈希表-JAVA代码实现原文地址，点击访问

哈希表（散列表）

key value 形式的数据结构，其基础是一个数组。哈希表在特定元素的插入，删除和查询时都能够达到O(1)常数的时间复杂度，除非发生hash碰撞

  • 哈希算法

    把任意长度的输入通过哈希算法转换映射为固定长度的输出，所得到的输出被称为哈希值

  • 哈希冲突解决

    • 开放地址法
    • 重新哈希法
    • 拉链法

  • 负载因子

    负载因子代表着存储的总数据量和内部数组大小的比值。插入新数据时，判断哈希表当前的存储量和内部数组的比值是否超过了负载因子。当比值超过了负载因子时，哈希表认为内部过于拥挤，查询效率太低，会触发一次扩容操作。

    指定的负载因子越大，哈希表越拥挤(负载高，紧凑)，查询效率越低，空间效率越高。

    指定的负载因子越小，哈希表越稀疏(负载小，松散)，查询效率越高，空间效率越低。

  • 代码（使用了拉链法解决hash冲突）

    • 示例

      public static void main(String[] args) {

        MyMap<String, String> map = new MyHashMap<>(10);

        map.put("zlz","zlz");
        map.put("zlz","zlz-zlz");
        map.put("zlz1","zlz1");
        map.put("zlz2","zlz2");
        map.put("zlz3","zlz3");
        map.put("zlz4","zlz4");

        System.out.println("-----------remove-test-------------");
        System.out.println("Key-zlz4存在：" + map.containsKey("zlz4"));
        map.remove("zlz4");
        System.out.println("Key-zlz4存在：" + map.containsKey("zlz4"));
        System.out.println("-----------containsValue-test-----------");

        System.out.println("Value-zlz存在：" + map.containsValue("zlz"));
        System.out.println("Value-zlz-zlz存在：" + map.containsValue("zlz-zlz"));
}

out:
    -----------remove-test-------------
    Key-zlz4存在：true
    移除了元素：zlz4
    Key-zlz4存在：false
    -----------containsValue-test-----------
    Value-zlz存在：false
    Value-zlz-zlz存在：true

    • MyMap（接口+内部类EntryNode（键值对））

      package hash;

/**
 * @author zlz
 * @version 1.0 CreateTime:2020-11-11 16:45
 * @description hash表，java中的Map结构
 */
public interface MyMap<K, V> {

    /**
     * 存入元素
     * @param k key
     * @param v value
     * @return key
     */
    V put(K k, V v);

    /**
     * 通过key移除元素
     * @param k key
     * @return value
     */
    V remove(K k);

    /**
     * 通过key获取value
     * @param k key
     * @return value
     */
    V get(K k);

    /**
     * 是否包含该key
     * @param k key
     * @return boolean
     */
    boolean containsKey(K k);

    /**
     * 是否包含该value
     * @param v value
     * @return boolean
     */
    boolean containsValue(V v);

    /**
     * 元素个数
     * @return 元素个数
     */
    int size();

    /**
     * hash表是否为空
     * @return boolean
     */
    boolean isEmpty();

    /**
     * 清空hash表
     * @return 成功或者失败
     */
    void clear();

    /**
     * 键值对类型，表示一个节点
     * @param <K>
     * @param <V>
     */
    class EntryNode<K, V>{
        K key;
        V value;
        EntryNode<K,V> next;

        EntryNode(K key, V value) {
            assert key != null;
            this.key = key;
            this.value = value;
        }

        /**
         * 判断传入的key与对象的key是否相等
         * @param k key
         * @return boolean
         */
        boolean equalsKey(K k){
            return this.key.equals(k);
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }

        public EntryNode<K, V> getNext() {
            return next;
        }

        public void setNext(EntryNode<K, V> next) {
            this.next = next;
        }

        @Override
        public String toString() {
            return "{" +
                    "key=" + key +
                    ", value=" + value +
                    '}';
        }
    }
}

    • MyHashMap（实现类）

      /**
 * @author zlz
 * @version 1.0 CreateTime:2020-11-11 17:00
 * @description hashmap
 */
public class MyHashMap<K,V> implements MyMap<K, V>{

    /**
     * 存储所有的键值对
     */
    private EntryNode<K, V>[] nodes;

    /**
     * 当前哈希表的大小
     * */
    private int size;

    /**
     * 负载因子，负载因子决定了hash表何时进行resize（扩容）操作
     */
    private final float loadFactor;

    /**
     * 默认的哈希表容量
     */
    private final static int DEFAULT_CAPACITY = 16;

    /**
     * 扩容翻倍的基数
     */
    private final static int REHASH_BASE = 2;

    /**
     * 默认的负载因子
     */
    private final static float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * 使用默认容量初始化
     */
    public MyHashMap() {
        this.size = 0;
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        nodes = new EntryNode[DEFAULT_CAPACITY];
    }

    /**
     * 指定初始化的容量大小
     * @param capacity 初始化的容量
     */
    public MyHashMap(int capacity) {
        this.size = 0;
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        nodes = new EntryNode[capacity];
    }

    /**
     * 通过hash计算获取数组的下标
     * @param key key
     * @return hash桶坐标
     */
    private int getIndex(K key){
        return getIndex(key,this.nodes);
    }

    /**
     * 通过hash计算获取数组的下标
     * @param key key
     * @param nodes 节点
     * @return hash桶坐标
     */
    private int getIndex(K key,EntryNode<K,V>[] nodes){
        if(key == null){
            return 0;
        }else{
            int hashCode = key.hashCode();
            // 异或运算，获得最终的hash映射，减少碰撞的几率
            int finalHashCode = hashCode ^ (hashCode >>> 16);
            return (nodes.length-1) & finalHashCode;
        }
    }

    /**
     * 试图获得目标节点，获取不到则返回链表的最后一个节点
     * @param currentNode 链表的第一个节点
     * @param key key
     * @return EntryNode
     */
    private EntryNode<K,V> getTargetEntryNode(EntryNode<K,V> currentNode, K key){
        // 不匹配
        EntryNode<K,V> nextNode = currentNode.next;
        // 遍历当前桶后面的所有节点
        while(true){
            if(nextNode == null || currentNode.key.equals(key)){
                return currentNode;
            }
            currentNode = nextNode;
            nextNode = currentNode.next;
        }
    }

    @Override
    public V put(K k, V v) {
        //创建键值对
        EntryNode<K, V> entryNode = new EntryNode<>(k, v);
        //通过key获取数组的下标
        int index = getIndex(k);
        EntryNode<K, V> firstNode = this.nodes[index];

        //若是此节点不存在数据，则直接插入该数据作为第一个节点
        if(firstNode == null){
            this.nodes[index] = entryNode;
            this.size++;
            if(this.size > this.nodes.length * this.loadFactor){
                this.resize();
            }
            return v;
        }

        // 若是此桶的第一个节点就是当前的key，就将该key对应的value替换掉，并且返回此oldValue
        if(firstNode.equalsKey(k)){
            V oldValue = firstNode.value;
            firstNode.value = v;
            return oldValue;
        //若是不匹配，则去链表的下一个节点查找，若是全部不匹配，则新增一个节点放在链表的末尾
        }else {
            EntryNode<K, V> targetEntryNode = getTargetEntryNode(firstNode, k);
            // 若是查找到了key相同的节点，则替换节点的value
            if(targetEntryNode.key.equals(k)){
                V oldValue = targetEntryNode.value;
                targetEntryNode.value = v;
                return oldValue;
            //未查询到匹配的节点
            }else {
                targetEntryNode.next = entryNode;
                this.size++;
                if(this.size > this.nodes.length * this.loadFactor){
                    this.resize();
                }
                return v;
            }
        }
    }

    @Override
    public V remove(K k) {

        int index = getIndex(k);
        EntryNode<K, V> firstNode = this.nodes[index];

        if(null == firstNode){
            return null;
        }

        // 链表第一个节点即为要移除的节点
        if(firstNode.key.equals(k)){
            this.nodes[index] = firstNode.next;
            System.out.println("移除了元素：" + k);
            this.size --;
            return firstNode.value;
        // 链表第一个节点不是要移除的节点
        } else {
            // 从第二个节点开始遍历
            EntryNode<K, V> preEntryNode = firstNode;
            EntryNode<K, V> curEntryNode = firstNode.next;
            while (null != curEntryNode) {
                if(curEntryNode.key.equals(k)){
                    break;
                }
                // 若是下一个节点为空，则说明链表遍历完成，但是也没有匹配到对应的节点
                if(null == curEntryNode.next){
                    return null;
                }
                preEntryNode = curEntryNode;
                curEntryNode = curEntryNode.next;
            }

            // 将其之前的节点连接到他的下一个节点上
            if(null != curEntryNode){
                System.out.println("移除了元素：" + k);
                this.size --;
                preEntryNode.next = curEntryNode.next;
                return curEntryNode.value;
            }
            return null;
        }
    }

    @Override
    public V get(K k) {
        int index = getIndex(k);
        EntryNode<K, V> node = this.nodes[index];
        while (null != node){
            if(node.key.equals(k)){
                return node.value;
            }
            node = node.next;
        }
        return null;
    }

    @Override
    public boolean containsKey(K k) {
        int index = getIndex(k);
        EntryNode<K, V> node = this.nodes[index];
        while (null != node){
            if(node.key.equals(k)){
                return true;
            }
            node = node.next;
        }
        return false;
    }

    @Override
    public boolean containsValue(V v) {
        for (EntryNode<K, V> node : this.nodes) {
            while (null != node){
                if(node.value.equals(v)){
                    return true;
                }
                node = node.next;
            }
        }
        return false;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        for (EntryNode<K, V> node : this.nodes) {
            if (null != node) {
                return false;
            }
        }
        return true;
    }

    @Override
    public void clear() {
        this.nodes = new EntryNode[this.nodes.length];
    }

    private void resize() {
        EntryNode<K, V>[] resizeArray = this.nodes;
        this.nodes = new EntryNode[this.nodes.length * REHASH_BASE];
        this.size = 0;
        for (EntryNode<K, V> node : resizeArray) {
            while (null != node){
                this.put(node.key, node.value);
                node = node.next;
            }
        }
        System.out.println("hash表已经扩容，目前容量：" + this.nodes.length);
    }
}

      数据结构之哈希表-JAVA代码实现原文地址，点击访问

zPeet
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈希表java实现及简单演示
09-11
这个是java版的哈希表演示程序，里面用到的散列函数及处理冲突的方法都相对简单，但是可以加深大家对哈希表的认识。
java哈希表代码实现
DrugHua的博客
04-30 416
使用了Emp(员工)类作为哈希表存储的数据类型,员工emp类属性id和name.实现了哈希表基本的增删查全显 import java.util.Scanner; /** * @author Drug * @create 2020-04-30 16:30 */ public class HashTab { public static void main(String[] args) ...
数据结构之哈希表
xiaotai1234的博客
10-02 343
数据结构之哈希表 package com.atguigu.hashtab; import java.util.Scanner; public class HashTabDemo { public static void main(String[] args) { //创建哈希表 HashTab hashTab = new HashTab(7); //写一个简单的菜单 String key = ""; Scanner scanner = new Scanner(S
JAVA代码实现哈希表
qq_41665523的博客
03-01 303
哈希表 哈希表也叫散列表，是根据关键码值而直接进行访问的数据结构，通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 举例：定义一个哈希表实现员工的增删改查 package com.hashTab; import java.util.Scanner; /* * 使用哈希表完成员工的增删改查 */ public class ...
Java——数据结构与算法（哈希表）思路图解分析 代码实现
Pausch的博客
07-22 273
哈希表 散列表(Hash table，也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 有一个公司，当有新的员工来报道时，要求将该员工的信息加入(id,性别，年龄，名字，住址.),当输入该员工的id时， 要求查找到该员工的所有信息 要求: 1)不使用数据库…速度越快越好=>哈希表(散列) 2)添加时，保证按照id 从低到高插入[课后思考: 如果i
哈希表-使用Java开发的哈希表-HashTable.zip
03-04
哈希表是一种高效的数据结构，它通过特定的算法（哈希函数）将数据映射到一个固定大小的数组中，从而实现快速的插入、查找和删除操作。在Java中，`HashTable`是早期版本（Java 1.0）提供的一种线程安全的哈希表实现...
最快的排序算法 javahash实现-Java-哈希算法-最快的实现，排序算法数据结构
04-07
8. 数据结构的选择：在选择数据结构时，需要考虑到ハシ表、树形结构、图结构等不同的数据结构的优缺点，并选择合适的数据结构来实现哈希算法。 9. 安全性问题：在实现哈希算法时，需要考虑到安全性问题，例如选择...
java-leetcode面试题解哈希表第170题数据结构设计-题解.zip
03-26
在编写Java代码时，可以使用HashMap或者自己实现哈希表，以满足题目所要求的特定功能。此外，注意代码的可读性和效率，这是面试中评价代码质量的重要标准。 通过深入理解和实践这道题，你不仅能巩固哈希表的基础...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归...斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
java-数据结构代码实现
11-15
本资料包“java-数据结构代码实现”提供了使用Java语言实现数据结构的实例，旨在帮助开发者加深对数据结构的理解并提升编程技能。 1. **链表**：链表是一种动态数据结构，其元素在内存中不是顺序排列的。Java中的...
常用的hash算法(java实现)
12-26
采用java实现的常用hash算法归总。
数据结构 哈希表 源代码
11-18
以一个用户信息管理，来建立哈希表，教会你建立基础的哈希表哈希，很适合初学者学习
数据结构用C++哈希表的源代码
11-04
数据结构中的哈希表问题，用C++编写的源代码
数据结构中哈希表的实现代码
10-18
这是数据结构中哈希表的实现代码，请大家在需要的时候尽量的下载。
哈希表的数据结构
06-29
哈希表的数据结构哈希表的数据结构哈希表的数据结构哈希表的数据结构
哈希表(java代码实现)
qq_22993855的博客
08-27 625
哈希表(java代码实现) 哈希表:又称为散列表(Hash Tab):是根据关键码(key value)而直接进行访问的数据结构,也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度; 其中映射函数也称为散列函数:用来存放记录的数组叫做散列表 简单理解:哈希表就是一个数组+加上链表的存储结构(数据结构) 代码实现: package com.bingym.hash; import java.util.Scanner; public class HashTabDemo { /*
JAVA数据结构与算法：哈希表、思路分析、代码实现
turbo小世界
06-10 115
哈希表 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 1、关于哈希表的题 有一个公司，当有新的员工来报道时，要求将该员工信息加入(id,姓名,年龄)，当输入该员工的id时，要求找到该员工的所有信息。 要求：不使用数据库，速度越快越好。 . 思路分析 有3个类： EmpHashTable类：根据id散列每个存入的值；创建
哈希表的java实现
weixin_33716154的博客
01-17 573
一、为什么要用哈希表 树的操作通常需要O(N)的时间级，而哈希表中无论存有多少数据，它的插入和查找（有时包括删除）只需要接近常量级的时间，即O(1)的时间级。 但是哈希表也有一定的缺点：它是基于数组的，数组创建后难以扩展。而某些哈希表在基本填满时，性能下降明显，所以事先必须清楚哈希表中将要存储多少数据。而且目前没有一种简便的方法可以对哈希表进行有序（从大到小或者从小到大）的遍历，除非哈...
Java实现数据结构---哈希表
coding is an art
10-24 362
1. 哈希表（Hash Table）也称为散列表，是一种根据关键字值（key - value）而直接访问的数据结构。它的底层是基于数组实现，通过对键值对的key进行Hash求值（哈希化）算出对应的数组下标索引，因此不需要遍历整个底层数组，插入删除效率均很快，被广泛应用。
哈希表内部java代码
最新发布
06-02
哈希表（Hash Table）是一种常用的数据结构，它支持高效的插入、查找和删除操作。在Java中，哈希表的实现类是HashMap。以下是HashMap内部的一部分Java代码，仅供参考： ``` public class HashMap, V> extends ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值