Java动态散列技术知识点（含面试大厂题和源码）

于 2024-04-09 18:49:26 发布
阅读量708 收藏 10
点赞数 20
文章标签： java 面试 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2302_80314137/article/details/137563290
版权

动态散列技术，也称为动态哈希或可扩展哈希，是一种自适应调整哈希表大小的技术。随着数据的增加或减少，动态散列技术能够自动调整哈希表的容量，以保持高效的操作性能。这种技术在处理大量动态数据时非常有用，因为它可以避免哈希冲突，并减少重新哈希的开销。

动态散列技术的特点：

  1. 动态调整大小：根据存储的数据量自动调整哈希表的大小。
  2. 负载因子：动态散列通常基于负载因子（表中元素数量与桶数量的比率）来决定何时扩展或收缩哈希表。
  3. 再散列：当哈希表决定扩展时，所有现有的键都需要通过新的散列函数重新散列到更大的表中。
  4. 性能稳定：通过动态调整大小，动态散列可以保持接近理想的平均查找时间复杂度。

动态散列技术的实现方法：

  1. 开放寻址法：当表中元素数量达到某个阈值时，增加哈希表的大小，并使用新的散列函数重新计算所有元素的位置。
  2. 链地址法：在链地址法中，哈希表的大小扩展后，只需要更新链表中节点的索引，因为链表的节点位置不依赖于哈希表的大小。
  3. 双重哈希法：使用两个散列函数，当第一个散列函数得到的位置上已经有元素时，使用第二个散列函数来寻找下一个空闲位置。

动态散列技术的Java实现（简单的开放寻址法）：

import java.util.HashMap;
import java.util.Map;

public class DynamicHashing {
    private static final int INITIAL_CAPACITY = 4;
    private static final double LOAD_FACTOR_THRESHOLD = 0.75;
    private int[] table;
    private int size;
    private double loadFactor;

    public DynamicHashing() {
        table = new int[INITIAL_CAPACITY];
        size = 0;
        loadFactor = 0.0;
    }

    public void insert(int key) {
        int index = hash(key);
        while (table[index] != 0 && table[index] != key) {
            index = (index + 1) % table.length;
        }
        if (table[index] == 0) {
            size++;
            if (loadFactor >= LOAD_FACTOR_THRESHOLD) {
                resize();
            }
        }
        table[index] = key;
        loadFactor = (double) size / table.length;
    }

    private int hash(int key) {
        return key % table.length;
    }

    private void resize() {
        int oldCapacity = table.length;
        int newCapacity = oldCapacity * 2;
        int[] oldTable = table;
        table = new int[newCapacity];
        size = 0;
        loadFactor = 0.0;
        for (int key : oldTable) {
            if (key != 0) {
                insert(key);
            }
        }
    }

    public static void main(String[] args) {
        DynamicHashing dynamicHash = new DynamicHashing();
        for (int i = 0; i < 10; i++) {
            dynamicHash.insert(i);
        }
        System.out.println("Current load factor: " + dynamicHash.loadFactor);
    }
}

在面试中，动态散列技术是一个重要的知识点，它考察应聘者对数据结构的理解和算法设计能力。通过实现动态散列技术，可以展示你对哈希表原理和动态数据结构的掌握程度。希望这些知识点和示例代码能够帮助你更好地准备面试！

题目 1：实现动态扩容的哈希表

描述：
设计一个哈希表，当哈希表的负载因子超过某个阈值时，自动扩容并重新散列所有元素。

示例：

插入一系列键值对，当负载因子超过0.75时，哈希表的容量加倍。

Java 源码：

import java.util.Arrays;

public class DynamicHashTable {
    private static final int INITIAL_CAPACITY = 4;
    private static final double LOAD_FACTOR_THRESHOLD = 0.75;
    private int[] keys;
    private Object[] values;
    private int size;
    private double loadFactor;

    public DynamicHashTable() {
        keys = new int[INITIAL_CAPACITY];
        values = new Object[INITIAL_CAPACITY];
        size = 0;
    }

    public void put(int key, String value) {
        int index = hash(key);
        for (int i = index; keys[i] != 0 && keys[i] != key; i = (i + 1) % keys.length) {
            // Find empty slot or existing key
            if (keys[i] == 0) {
                break;
            }
        }
        if (keys[i] == 0) {
            keys[i] = key;
            values[i] = value;
            size++;
            if (loadFactor > LOAD_FACTOR_THRESHOLD) {
                resize();
            }
        } else {
            values[i] = value; // Update existing key-value pair
        }
    }

    private int hash(int key) {
        return Math.abs(key % keys.length);
    }

    private void resize() {
        int oldCapacity = keys.length;
        int newCapacity = oldCapacity * 2;
        int[] oldKeys = keys;
        Object[] oldValues = values;
        keys = new int[newCapacity];
        values = new Object[newCapacity];
        size = 0;
        for (int i = 0; i < oldCapacity; i++) {
            if (oldKeys[i] != 0) {
                put(oldKeys[i], (String) oldValues[i]);
            }
        }
    }

    public static void main(String[] args) {
        DynamicHashTable hashTable = new DynamicHashTable();
        for (int i = 0; i < 12; i++) {
            hashTable.put(i, "Value" + i);
        }
        System.out.println("Hash table size: " + hashTable.keys.length);
    }
}

题目 2：解决散列冲突的链地址法

描述：
实现一个使用链地址法解决散列冲突的哈希表，并提供插入和查找操作。

示例：

插入键值对 (1, "a") 和 (1, "b")，查找键为 1 的所有值。

Java 源码：

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

public class ChainingHashTable {
    private static final int INITIAL_CAPACITY = 4;
    private List<Object>[] table;

    public ChainingHashTable() {
        table = new ArrayList[INITIAL_CAPACITY];
        for (int i = 0; i < table.length; i++) {
            table[i] = new ArrayList<>();
        }
    }

    public void put(int key, String value) {
        int index = Math.abs(key % table.length);
        table[index].add(new KeyValue(key, value));
    }

    public List<String> get(int key) {
        int index = Math.abs(key % table.length);
        for (Object obj : table[index]) {
            if (obj instanceof KeyValue && ((KeyValue) obj).key == key) {
                return ((KeyValue) obj).value;
            }
        }
        return null;
    }

    private static class KeyValue {
        int key;
        List<String> value;

        KeyValue(int key, String value) {
            this.key = key;
            this.value = new ArrayList<>();
            this.value.add(value);
        }
    }

    public static void main(String[] args) {
        ChainingHashTable hashTable = new ChainingHashTable();
        hashTable.put(1, "a");
        hashTable.put(1, "b");
        System.out.println("Values for key 1: " + hashTable.get(1));
    }
}

题目 3：实现哈希表的删除操作

描述：
设计一个哈希表，并提供删除操作。当删除元素时，如果该位置有多个元素，需要删除与给定键匹配的第一个元素。

示例：

哈希表中包含键值对 (1, "a") 和 (1, "b")，删除键为 1 的第一个值。

Java 源码：

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

public class HashTableDelete {
    private static final int INITIAL_CAPACITY = 16;
    private List<Object>[] table;

    public HashTableDelete() {
        table = (List<Object>[]) new List[INITIAL_CAPACITY];
        for (int i = 0; i < table.length; i++) {
            table[i] = new ArrayList<>();
        }
    }

    public void put(int key, String value) {
        int index = Math.abs(key.hashCode() % table.length);
        table[index].add(new KeyValue(key, value));
    }

    public boolean delete(int key) {
        int index = Math.abs(key.hashCode() % table.length);
        for (int i = 0; i < table[index].size(); i++) {
            KeyValue kv = (KeyValue) table[index].get(i);
            if (kv.key == key) {
                table[index].remove(i);
                return true;
            }
        }
        return false;
    }

    private static class KeyValue {
        int key;
        String value;

        KeyValue(int key, String value) {
            this.key = key;
            this.value = value;
        }
    }

    public static void main(String[] args) {
        HashTableDelete hashTable = new HashTableDelete();
        hashTable.put(1, "a");
        hashTable.put(1, "b");
        hashTable.put(2, "c");
        hashTable.delete(1);
        System.out.println("Hash table after deletion: " + Arrays.toString(hashTable.table));
    }
}

这些题目和源码展示了动态散列技术在解决实际问题中的应用。在面试中，能够根据问题的特点选择合适的算法并实现其解决方案是非常重要的。希望这些示例能够帮助你更好地准备面试！

互联网大厂高频面试题基本总结回顾（含笔试高频算法整理）
张彦峰的博客
04-03 176万+
1.自我介绍+项目介绍+项目细节/难点提问-------这个主要看个人的经历了，每个人都不一样 2.基础知识点考核---------还是可以去增强自己的，也是这次的主要的一些总结思路 3.算法题-----------一般都是LeetCode高频题，这个得在找工作之前的好好的练习(d对常见的高频题进行总结分析，见对应的链接提示)
Java高频面试基础问题与知识点整理
热门推荐
张彦峰的博客
11-04 171万+
Java高频面试知识点总结：覆盖高频基础知识考点+高频集合知识点深入分析+高频多线程与并发编程面试题汇总+其他扩展考察等。
动态散列索引
mmmmhello的博客
07-22 728
可扩展散列索引 散列索引是将键值通过散列函数，将记录分布到不同的桶当中，这里的桶就指的是存储地比如磁盘块或者内存页等。而根据桶的个数是否确定，可将散列索引分为静态散列索引和动态散列索引。可扩展散列索引就是一种动态散列索引，可以根据记录的增加或者减少来修改桶的个数。可扩展散列索引中通并不是存储地，而是指向存储地的指针。散列函数将键值转化为一个N个的二进制位，将该N个二进制位的前i个表示桶的数目，比如i= 2 那么就有2^2=4个桶。现在有这样一个极端的问题,我们假设一个桶可以存储2条记录，那么假设有3条记..
动态hash思想方法
WSTMQ的专栏
10-20 2078
文章出处：http://blog.sina.com.cn/s/blog_5e4516af01019frj.html 散列是一个非常有用的、非常基础的数据结构，在数据的查找方面尤其重要，应用的非常广泛。然而，任何事物都有两面性，散列也存在缺点，即数据的局部集中性会使散列的性能急剧下降，且越集中，性能越低。 数据集中，即搜索键在通过hash函数运算后，得到同一个结果，指向同一个桶，这时便产
数据库系统概念之索引与散列
weixin_45754452的博客
01-04 3657
文章目录基本概念索引类型索引好坏衡量标准顺序索引索引种类索引的更新B+树索引叶结点非叶结点平衡树范围查询结点分裂结点合并不唯一搜索码B+树文件组织批量加载自底向上B+树构建B树索引静态散列桶散列函数桶溢出偏斜闭地址动态散列可扩充散列多码访问多码索引位图索引位图操作 基本概念 索引是由于需要快速访问文件中的记录(行)这种需求而产生的，通过索引可以快速定位到文件中的某条记录在哪个块中 索引类型 有两种基本的索引类型： 顺序索引：根据值的顺序对记录进行顺序排序，然后建立的索引，也可以是值不排序，但是对值的索引进
【数据库原理系列】索引结构---散列
菜鸡也有大佬梦
11-27 1814
实现：散列索引 散列 有M个桶，每个桶是有相同容量的存储块(可以是内存页，也可以是磁盘块) 内存数据可采用散列确定存储页，主文件可采用散列确定存储块，索引亦可采用散列确定索引项的存储块 Ｍ个桶。一个桶可以是一个存储块，亦可是若干个连续的存储块。 散列函数 h(k)，可以将键值k映射到 {0,1,…,M-1}中的某一个值 将具有键值k的记录Record(k)存储在对应h(k)编号的桶中 在键值几倍于桶的数目时，每个散列值都可能多于一个桶，形成一个主桶和多个溢出桶的列表，此时需要二
散列表：如何打造一个工业级水平的散列表？
贾欣晓的博客
10-22 197
开放寻址法的缺点：开放寻址法解决冲突的散列表，删除数据比较麻烦，需要特殊标记已经删掉的数据。在开放寻址法中，所有的数据都存储在一个数组中，比起链表法来说，冲突的代价更高。所以，使用开放寻址法解决冲突的散列表，装载因子的上限不能太大。这也导致这种方法比链表法更浪费内存空间。总结：当数据量比较小、装载因子小的时候，适合采用开放寻址法。这是java中的ThreadLocalMap使用开放寻址法解决散列冲突的原因。
Java 面经手册·小傅哥.pdf
01-26
当你仔细阅读书籍时，会发现Java中有大量的数学知识，包括：扰动函数、负载因子、拉链寻址、开放寻址、斐波那契（Fibonacci）散列法还有黄金分割点的使用等等。 适合人群 1. 具备一定编程基础，工作1-3年的研发...
Java必须掌握的哈希知识点（含面试大厂题含源码）
最新发布
2302_80314137的博客
03-15 1190
在Java中，哈希表是一种非常重要的数据结构，常用于存储键值对，提供快速的查找、插入和删除操作。在面试大厂时，你可能会遇到与哈希表相关的知识点和问题。以下是一些关键的哈希表知识点，它们对于准备Java面试非常有用： ### 1. 哈希表基本概念 - **定义**：哈希表（Hash Table），也称为散列表，是基于快速访问的数据结构。它通过一个哈希函数将键（key）映射到表中一个位置来访问记录，以加快查找速度。 - **工作原理**：哈希表使用哈希函数将输入（通常是一个键）转换成一个索引，该索引指示元素在
各大厂800道Java后端经典面试题合集
weixin_70730532的博客
08-30 2204
另外，面试题答案的话，可以私信我， 希望大家都能找到自己理想的offer呀。
【数据库复习 9】
qq_57124671的博客
08-25 457
《数据库系统概念》读书笔记
《数据库系统概念》15-可扩展动态散列
zhixin9001的博客
12-30 1500
静态散列要求桶的数目始终固定，那么在确定桶数目和选择散列函数时，如果桶数目过小，随着数据量增加，性能会降低；如果留一定余量，又会带来空间的浪费；或者定期重组散列索引结构，但这是一项开销大且耗时的工作。为了应对这些问题，为此提出了几种动态散列(dynamic hashing)技术，可扩展动态散列(extendable hashing)便是其一。 一、可扩展动态散列 A)用一个数组来存
动态hash办法（数据库索引技巧）
计算机技术博客
12-26 3594
本文将介绍三种动态hash办法。       散列是一个很是有效的、很是根蒂根基的数据布局，在数据的查找方面尤其首要，应用的很是广泛。然而，任何事物都有两面性，散列也存在毛病，即数据的局部集中性会使散列的机能急剧降落，且越集中，机能越低。       数据集中，即搜刮键在经由过程hash函数运算后，获得同一个成果，指向同一个桶，这时便产生了数据冲突。       凡是解决数据冲突
增加桶式的动态哈希
紫云的博客
10-20 2491
哈希值的获取字符串的二进制，再二进制转换为一组数字，这组数字就是用来确定key在哪个桶层中的 代码中  #define tongsize 8 //桶大小是2的n次方，，，，，这里的n=3（2的3次方等于8），那么会把3个二进制转换为一个数字 /* 当重新分配还是分配到一个桶层时候，会出现哈希key不够用，就会出现引用了无效内存的bug，所以使用more_ceng arr[j]=
动态查找之哈希（hash）表
心之所向
09-08 2035
一、介绍　　与其他建立在“比较”基础上的查找算法不同，哈希表是通过哈希函数将储存位置与值得关键字建立一一对应关系，从而一般一次就能够得到值。但是有时对于不同关键字哈希后得到的地址会是相同的，称这种现象为冲突。具有相同哈希值的关键字称为同义词。二、哈希函数哈希函数一般都是尽可能是的关键字随机性较大，出现相同概率小。 直接定址法：根据关键词由哈希函数直接计算得地址 数字分析法：分析关键字规律，尽
散列
Hulk
05-29 725
1.散列搜索算法由两部分组成：1.计算一个散列函数：将搜索关键字转换为表中地址。2.冲突解决：处理多个关键字对应同一个地址的情况。2.散列缺点：1.运行时间依赖于关键字长度，对于长关键字不利。2.对于选择和排序操作，散列不能带来高效。散列一般应用于有大量搜索、插入、删除的操作中。3.散列函数：散列函数将关键字的值转化为表中的地址。一个好的散列函数应该考虑关键字的全部位。理想的通用散列函数使得表中两...
数据库索引(Index)
云原生Java Web领域技术博客
04-25 9505
索引（Index）是帮助数据库高效获取数据的数据结构。 如果将数据库比作书，那么索引就相当于目录。
动态hash之linear Hash的实现和性能比较
train的专栏
07-31 5761
linear hash   一，在介绍linear hash 之前，需要对动态hash和静态hash这两个概念做一下解释：   静态hash：是指在hashtable初始化得时候bucket的数目就已经确定了，当需要插入一个元素的时候，通过hash函数找到对应的bucket number，之后插入即可。不论用什么冲突解决方法，当插入的元素越来越多时，在这个hash表中查找元素的效率会变的越
Java面试题大全：核心知识点与BAT大厂面试题解析
具体覆盖了Java基础知识、BAT（百度、阿里巴巴、腾讯）等大厂面试题、以及dubbo、jvm、mybatis、netty、redis、spring boot、spring cloud、springmvc等重要技术点。下面将对这些知识点进行详细说明。 ### Java基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值