[土味]自制HashTable

最新推荐文章于 2023-04-26 17:38:08 发布
最新推荐文章于 2023-04-26 17:38:08 发布
阅读量187 收藏
点赞数
分类专栏： 土味 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34067387/article/details/107769288
版权

自定义一个简单的散列表

目录

主要功能

通过java代码实现一个简单的HashTable数据结构,可以进行增删查,并实现迭代器,以及自动扩容.

代码实现

package com.example.springboot01.util;

import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;

/**
 * 自制散列表,使用数组+链表实现
 */
public class MyHashTable<T> {
    // 容器中元素的个数
    private int size = 0;
    // 散列表长度
    private static int tableSize = 120000;
    // 不指定泛型,需要自己控制输入的类型
    private MyLinkedList<T>[] array = new MyLinkedList[tableSize];

    public MyHashTable() {
        // 初始化链表
        for(int i=0; i<tableSize; i++) {
            MyLinkedList<T> list = new MyLinkedList<>();
            array[i] = list;
        }
    }

    /**
     * 插入
     * @param t T
     */
    public void add(T t) {
        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            // 获取到MyLinkedList对象
            MyLinkedList<T> list = array[index];
            // 如果已存在,则跳过
            if(list.size() > 0 && list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    if(t.equals(itr.next())) {
                        return;
                    }
                }
            }
            // 不存在,执行插入
            list.add(t);
            // 容器中元素个数加一
            size++;
        }
    }

    /**
     * 删除指定元素
     * @param t 元素
     */
    public void remove(T t) {
        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            MyLinkedList<T> list = array[index];
            if(list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    // 比较两个字符串是否相等
                    if(t.equals(itr.next())) {
                        // 删除元素
                        itr.remove();
                        // 容器中元素的个数减一
                        size--;
                    }
                }
            }
        }
    }

    /**
     * 判断容器中是否包含某个元素
     * @param t 元素
     * @return  boolean
     */
    public boolean contains(T t) {
        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            MyLinkedList<T> list = array[index];
            if(list.size() > 0 && list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    if(t.equals(itr.next())) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 迭代器类,这并不是真正的迭代器,只是为了迭代而迭代,用不着定义泛型.
     * 按先数组后链表的顺序依次遍历
     */
    public class Itr {
        // 遍历过程中当前数组下标
        private int currentIndex = 0;
        // 遍历过程中当前链表索引
        private int currentNode = -1;
        // 遍历过程中当前游标
        private int cursor = -1;

        /**
         * 是否存在下一个元素
         * @return
         */
        public boolean hasNext() {
            return cursor+1 < size();
        }

        public T next() {
            // 游标加一
            cursor++;
            // 当前节点加一
            currentNode++;

            // 如果当前节点超出了当前链表的长度,则移动到下一个链表的第一个节点
            if(array[currentIndex].size() < (currentNode+1)) {
                currentIndex++;
                currentNode = 0;
                // 如果下一个链表为空,则移动到再下一个链表
                while(array[currentIndex].size() == 0) {
                    currentIndex++;
                }
            }
            return array[currentIndex].get(currentNode);
        }

        /**
         * 删除元素
         */
        public void remove() {
            // 直接调用MyLinkedList里面的remove方法删除当前节点
            array[currentIndex].remove(currentNode);
            // 游标减一
            cursor--;
            // 容器中元素的个数减一
            size--;
            // 当前链表索引减一
            currentNode--;
        }
    }

    /**
     * 返回迭代器对象
     * @return Itr
     */
    public Itr iterator() {
        return new Itr();
    }

    /**
     * 返回容器中元素的个数
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 计算字符串的key,用于确定对应到散列表的哪个单元格
     * @param str 元素
     * @return  key
     */
    public int getAsc(String str) {
        int hashVal = 0;
        for(char c: str.toCharArray()) {
            hashVal = 31 * hashVal + c;
            //System.out.println(hashVal);
        }
        hashVal %= tableSize;
        if(hashVal < 0) {
            hashVal += tableSize;
        }
         return hashVal;
    }

    @Test
    public void testMyHashTable() {
        long startTime = System.currentTimeMillis();
        MyHashTable<String> myHashTable = new MyHashTable<>();
        for(int i=0; i<100000; i++) {
            myHashTable.add("Hello" + i);
        }

        MyHashTable<String>.Itr itr2 = myHashTable.iterator();
        while(itr2.hasNext()) {
            String content = itr2.next();
        }
        long middleTime = System.currentTimeMillis();
        System.out.println("totalTime: " + (System.currentTimeMillis() - startTime) + "ms");
        System.out.println("contains Hello100? : " + myHashTable.contains("Hello100"));
        System.out.println("contains: Hell100? : " + myHashTable.contains("Hell100"));
        System.out.println("totalTime: " + (System.currentTimeMillis() - middleTime) + "ms");

    }

}

性能测试

在这里插入图片描述

可以看到,对于10万之内的数据,速度都很快.

代码优化

增加了自动扩容部分

package com.example.springboot01.util;

import org.junit.Test;

/**
 * 自制散列表,使用数组+链表实现
 */
public class MyHashTable<T> {
    // 容器中元素的个数
    private int size = 0;
    // 散列表长度
    private static int tableSize = 16;
    // 加载因子,容器中所有元素的个数与容器容量的比值
    private int loadFactor = 1;

    // 测试用,记录所有链表中最长是多长
    public int deepth = 0;

    // 测试用,记录数组空白单元格
    public int blankCellNum = 0;

    // 测试用,记录数组所有单元格
    public int allCellNum = tableSize;

    // 不指定泛型,需要自己控制输入的类型
    private MyLinkedList<T>[] array = new MyLinkedList[tableSize];

    public MyHashTable() {
        // 初始化链表
        for(int i=0; i<tableSize; i++) {
            MyLinkedList<T> list = new MyLinkedList<>();
            array[i] = list;
        }
    }

    /**
     * 插入
     * @param t T
     */
    public void add(T t) {
        if((size+1) > tableSize * loadFactor) {
            // 扩容
            expandArray();
        }

        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            // 获取到MyLinkedList对象
            MyLinkedList<T> list = array[index];
            // 如果已存在,则跳过
            if(list.size() > 0 && list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    if(t.equals(itr.next())) {
                        return;
                    }
                }
            }
            // 不存在,执行插入
            list.add(t);
            // 容器中元素个数加一
            size++;
        }
    }

    /**
     * 删除指定元素
     * @param t 元素
     */
    public void remove(T t) {
        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            MyLinkedList<T> list = array[index];
            if(list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    // 比较两个字符串是否相等
                    if(t.equals(itr.next())) {
                        // 删除元素
                        itr.remove();
                        // 容器中元素的个数减一
                        size--;
                    }
                }
            }
        }
    }

    /**
     * 判断容器中是否包含某个元素
     * @param t 元素
     * @return  boolean
     */
    public boolean contains(T t) {
        if(t instanceof Integer) {

        }
        else if(t instanceof String) {
            int index = getAsc((String)t);
            MyLinkedList<T> list = array[index];
            if(list.size() > 0 && list.get(0) != null) {
                // 依次比较
                MyLinkedList<T>.Itr<T> itr = list.iterator();
                while(itr.hasNext()) {
                    if(t.equals(itr.next())) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 扩容
     */
    private void expandArray() {
        //System.out.println("===========================================expand start==========================================");
        tableSize = tableSize + (tableSize >> 1);
        allCellNum = tableSize;
        // 新建一个数组
        MyLinkedList<T>[] newArray = new MyLinkedList[tableSize];
        // 初始化链表
        for(int i=0; i<tableSize; i++) {
            MyLinkedList<T> list = new MyLinkedList<>();
            newArray[i] = list;
        }

        // 将原先的元素复制到新数组中
        Itr itr = iterator();
        while(itr.hasNext()) {
            T t = itr.next();
            if(t instanceof Integer) {

            }
            else if(t instanceof String) {
                int index = getAsc((String)t);
                // 获取到MyLinkedList对象
                MyLinkedList<T> list = newArray[index];
                // 执行插入
                list.add(t);
            }
        }
        array = newArray;
        //System.out.println("===========================================expand end==========================================");
    }


    /**
     * 迭代器类,这并不是真正的迭代器,只是为了迭代而迭代,用不着定义泛型.
     * 按先数组后链表的顺序依次遍历
     */
    public class Itr {
        // 遍历过程中当前数组下标
        private int currentIndex = 0;
        // 遍历过程中当前链表索引
        private int currentNode = -1;
        // 遍历过程中当前游标
        private int cursor = -1;

        /**
         * 是否存在下一个元素
         * @return
         */
        public boolean hasNext() {
            return cursor+1 < size();
        }

        public T next() {
            // 游标加一
            cursor++;
            // 当前节点加一
            currentNode++;
            // 如果当前节点超出了当前链表的长度,则移动到下一个链表的第一个节点
            if(array[currentIndex].size() < (currentNode+1)) {
                currentIndex++;
                //System.out.println("第" + currentIndex + "个链表");
                currentNode = 0;
                // 如果下一个链表为空,则移动到再下一个链表
                while(array[currentIndex].size() == 0) {
                    currentIndex++;
                    //System.out.println("第" + currentIndex + "个链表");
                    blankCellNum++;
                }
            }
            if(deepth < (currentNode + 1)) {
                deepth = currentNode + 1;
            }
            return array[currentIndex].get(currentNode);
        }

        /**
         * 删除元素
         */
        public void remove() {
            // 直接调用MyLinkedList里面的remove方法删除当前节点
            array[currentIndex].remove(currentNode);
            // 游标减一
            cursor--;
            // 容器中元素的个数减一
            size--;
            // 当前链表索引减一
            currentNode--;
        }
    }

    /**
     * 返回迭代器对象
     * @return Itr
     */
    public Itr iterator() {
        return new Itr();
    }

    /**
     * 返回容器中元素的个数
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 计算字符串的key,用于确定对应到散列表的哪个单元格
     * hashCode有可能为负,因为超出了int类型的最大值
     * @param str 元素
     * @return  key
     */
    public int getAsc(String str) {
        int hashVal = 0;
        for(char c: str.toCharArray()) {
            // 对于我这个例子,10万条数据11效果是最好的,String里面的散列函数使用的是31,可能原因是31=2<<8-1,计算比较快,又是质数
            hashVal = 11 * hashVal + c;
        }
        hashVal %= tableSize;
        if(hashVal < 0) {
            hashVal += tableSize;
        }
         return hashVal;
    }

    @Test
    public void testMyHashTable() {
        long startTime = System.currentTimeMillis();
        MyHashTable<String> myHashTable = new MyHashTable<>();
        for(int i=0; i<100000; i++) {
            myHashTable.add("Hello" + i);
        }

        long middleTime = System.currentTimeMillis();
        System.out.println("insertCost: " + (System.currentTimeMillis() - startTime) + "ms");
        MyHashTable<String>.Itr itr2 = myHashTable.iterator();
        myHashTable.deepth = 0;
        myHashTable.blankCellNum = 0;
        while(itr2.hasNext()) {
            String content = itr2.next();
            //System.out.println(content);
        }
        System.out.println("readCost: " + (System.currentTimeMillis() - middleTime) + "ms");
        System.out.println("maxDeepth: " + myHashTable.deepth);
        System.out.println("blankCellNum: " + myHashTable.blankCellNum);
        System.out.println("allCellNum: " + myHashTable.allCellNum);

    }

}

总结

  1. 散列表可以用来以常数平均时间实现插入和查找操作
  2. 散列函数的理想状态是容器中的元素平均分布在每个单元格内,链表的长度都为1.但实际上测试结果发现总会有20%以上的单元格是空着的,剩余的80%单元格承担着所有元素.这还是优化散列函数的结果,就是上面的getAsc()方法.不同的散列方法结果相差很大,需要调参数.HashSet里面使用的是31,网上说原因是31是质素,且31 = 2<<5-1,计算机计算比较快,我这边实际测试下来,11的分布结果是最好的.测试结果如下表1.
  3. 数组的初始长度影响不是很大,HashSet里面使用的是16,原因不知道,我这边测试了一下,[10-30]哪个数每次累加一半,10万以内,成为质数的次数最多,结果显示11反而是最多的,16少一个,其他的数结果也差不多.测试结果如下表2,代码如下.
  4. 对于现在的计算机来说,数组的扩容完全可以指数增长,而不用担心内存不够,这样可以减少扩容的次数.

表1

数据量链表最大长度(越小越好)未使用单元格数量(越少越好)全部单元格数量
11100K231879118342
31100K441811118342

表2

次数次数
105214
117225
122234
133246
144251
155260
166272
172281
182293
192305
205

表2测试代码:

/**
     * 测试[10-30]哪个数每次累加一半,10万以内,成为质数的次数最多
     */
    @Test
    public void testNum() {
        for(int i=10; i<31; i++) {
            int count2 = 0;
            int k = i;
            while(k < 1000000) {
                if(isPrimeNumber(k)) {
                    count2++;
                }
                k = k + (k >> 1);
            }
            System.out.println(i + ": " + count2);
        }
    }

    /**
     * 判断是否是质素
     * @param num
     * @return
     */
    public boolean isPrimeNumber(int num) {
        for(int i=2; i<num; i++) {
            if(num % i == 0) {
                return false;
            }
        }
        return true;
    }

参考资料

<<数据结构与算法分析>>

脚着沃土长望星空
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVASCRIPT HashTable
10-31
JAVASCRIPT HashTable
利用C语言实现HashTable
09-05
在IT领域，哈希表（HashTable）是一种常用的数据结构，它通过哈希函数将键（Key）映射到数组的索引位置，从而快速查找、插入和删除数据。本篇文章将详细探讨如何利用C语言实现一个简单的哈希表。 首先，我们需要...
自制的hash,myHash1,网页实现
chuicuoyou6663的博客
06-25 187
<!doctype html> <html> <head> <meta charset="UTF-8"> <title>myHash1</title> <link rel="stylesheet...
打造最快的Hash表(和Blizzard的对话)
狂飙的蜗牛
01-23 974
 開元最近学习了一下Blizzard的MPQ文件格式，颇有一些心得，其中一条就是对HastTable的理解，很想写出来给大家共享，感谢Justin Olbrantz的文章《Inside MoPaQ》，大多认识来源于此。  先提一个简单的问题，如果有一个庞大的字符串数组，然后给你一个单独的字符串，让你从这个数组中查找是否有这个字符串并找到它，你会怎么做？有一个方法最简单，老老实实从头查到尾，
新手友好向——如何创建一个简单的链表 : (
xieyv的博客
04-26 340
创建新节点，需要用malloc函数来申请内存空间来存放节点，并设置数据和指向下一个节点的指针。这样就有了一个能实现基本功能的链表了，但是也只是能实现基础功能（简单来说，把数据和指针串在一起，就形成了链表。其中一个成员用来存放数据，另一个则用来指向下一个节点。来自一个刚学完链表的蒟蒟蒟蒻，代码写的依托答辩 : (首先我们需要创建一个结构体，来作为节点。接下来定义头指针变量，用来作为链表的起点。输出链表中的第index的值。插入元素，以在开头插入为例。删除元素，以删除第一个为例。
java自制链表
A_super_C的博客
02-07 941
众所周知，java自身库是有包涵链表的，但是有的数据结构老师和算法老师可能会让学生自己写链表。这里就演示个简单的单链表和双链表，并实现链表的增删改基础功能。链表的话，可以先进先出，后进先出。可以把链表看成杯子，杯口就叫他它head，杯底叫tail由于加入节点是从head端加的且为单链表，所以第一个节点进来的时候tail就和第一个节点绑定了，后面除了删除tail节点会导致tail节点变更，不然后续操作tail节点都不会动。至于addafter方法，则为在链表中指定节点后面加入新节点，若指定节点在链表中不存在，
纯手工打造C++单链表，实现增删改查等基本功能
我的代码管家---houwenbin的专栏
01-04 2278
一直以来，对于数据结构都是后怕，但还是要啃下这骨头的： #pragma once /* * Copyright (c) 侯文斌 * All rights reserved. * * 作 者：houwenbin1986@gmail.com * 摘 要：链表的操作 */ //带头节点的链表 class LinkedList { struct Node { public: int da
java hashtable实现代码
09-04
Java中的`Hashtable`类是Java集合框架的一部分，它是一个基于哈希表的Map接口实现。这个数据结构允许我们以键值对的形式存储数据，并且提供了快速的插入、删除和查找操作。`Hashtable`是线程安全的，因此可以在多...
c语言实现的hashtable分享
09-04
}int hash_remove(HashTable *ht, char *key) { int index = hash_index(ht, key); Bucket *bucket = &ht->buckets[index]; Bucket *prev = NULL; while (NULL != bucket) { if (strcmp(key, bucket->key) == 0) { ...
asp.net Hashtable 遍历写法
10-30
在ASP.NET中，`Hashtable`是一个非常常用的集合类，它是一个无序的键值对（Key-Value Pair）集合，可以存储任何类型的对象。`Hashtable`是基于哈希表实现的，因此它提供了快速的查找性能。在处理大量数据或者需要...
自己制作一个链表用来存储列表信息，并查找当前id信息，找上一条信息，下一条信息(信息浏览的时候方便使用)...
weixin_33910759的博客
03-24 170
偶然看到某些网站在新闻详情中 ，往往是需要根据当前信息id获取到上一条信息和下一条信息的，而通常我们的做法是先获取当前信息，再获取上一条信息，再获取下一条信息，就需要发送三次查询才能够得到这些信息，一些编程网站或者论坛给出的方案是用SQL union写的。 比如当前id为5 想获取当前信息 上一条信息 下一条信息就是 (select * from news where id &lt;5 orde...
制作一个链表的方法
xvjixiang的专栏
04-15 923
首先，链表需要有
自己实现单链表Link-通俗易懂
蓝星花
06-07 1484
前言 链表在我们日常的开发过程中应该说是非常常见,各种网络框架用到的队列，底层用到的都是链表.相信有一句话大家都听书过：集合更适合查询操作，链表更适合频繁的插入，删除操作 实现单链表的思路 链表类，数据节点 节点类包含数据，和对下个节点的引用 完整代码 package com.cxx.list; /** * @Author: cxx * 单链表 * @Date: 2...
链表基础知识（创建、删除、插入）
Gcc_diyishuai的博客
07-27 232
链表是一种常见的重要的数据结构。它是动态进行存储分配的一种结构。链表中各元素在内存中的地址可以是不连续的。要找到某一元素，必须先找到上一个元素，根据它提供的下一个元素的地址才能找到下一个元素。如果不提供”头指针“则整个链表都无法访问。链表如同一条铁链一样，中间不能断开。链表这种数据结构，必须利用指针变量才能实现，即一个结点中应包含一个指针变量，用它存放下一结点的地址。 静态链表是很简单的，所有结点...
自定义链表（一）——小试牛刀
改变世界的力量
07-18 174
自定义链表（一）——小试牛刀 我们除了上次我们讲到自定义队列，当然，我们同样可以自定义链表，不过我觉得自定义链表要比自定义队列更抽象，所以，当你顿悟到自定义列表的奥义时，内心的成就感好强烈的说，恨不得一下子吧他更多的方法都实现。在我最初与自定义链表交手的时候最容易犯的错误就是空指针。所以，大家一定要注意啊，链表可不是随随便便就能打倒的小怪兽啊~要加油哦； 在编写自定义链表的时候，我们不仅需...
Filter过滤器,Intercepter拦截器,RequestBodyAdvice,ResponseBodyAdvice,AOP使用总结
sinat_34067387的博客
09-25 3325
最近看项目代码,发现里面用到了过滤器,拦截器等来对请求参数和返回参数做校验,加密,解密,种类太多,容易混淆,这里做一下记录. 1.Filter过滤器 Filter是Servlet规范中规定的，只能用于WEB中, 在Servlet前后起作用 使用场景:对入参进行校验, 校验不通过返回错误信息. 原理: 基于函数回调 使用方式: @WebFilter(urlPatterns = "/home/*") public class Filter1 implements Filter { @Overri.
卡牌游戏小猫钓鱼
sinat_34067387的博客
02-11 2555
java实现小猫钓鱼
判断两个集合是否存在交集
sinat_34067387的博客
06-03 2264
快速判断两个有限集合是否存在交集 先将一个集合存入Map数据结构中 然后依次从Map中去取另一个集合中的元素 如果取得到，说明存在交集 利用了数组的随机存取特性，匹配速度很快，时间复杂度是两个集合的大小之和。 /** * 快速判断两个集合是否存在交集 * 时间复杂度：2n */ @Test public void testJiaoji() { String[] aa = new String[]{"datou", "xiaoming"
使用 Java 对图像进行各种处理
sinat_34067387的博客
10-22 2227
接上一篇的使用 Java 提取图片的色彩边界,这一篇增加了去除噪点,锐化,模糊,S曲线加深,各向异性等处理,想做成类似于 PS 的人物卡通化的功能的,失败了,效果不行. 这其中参考了大量的网上例子,感谢各位大佬的分享,引用网址都在代码里面了. 引入jar包 <!-- java图片工具 https://mvnrepository.com/artifact/net.coobird/thumbnailator --> <dependency> <groupId>ne.
openpyxl hashtable
最新发布
06-02
在Python中，str、bytes、数字类型和tuple等基本数据类型都是HashTable，而用户自定义数据类型默认也是HashTable，因为它们的hash值就是id()值。只有当tuple内的所有项都是HashTable的时候，tuple才是HashTable。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值