个人博客：个人主页

个人专栏：JAVA

️  功不唐捐，玉汝于成

---

目录

前言

正文

1. 开放寻址法（Open Addressing）：

代码 ：

2. 链地址法（Chaining）：

代码 

3. 其他方法：

再哈希（Rehashing）：

代码：

完全随机化哈希函数：

代码：

哈希桶分割：

代码：

结语

 我的其他博客

---

前言

        在设计和实现哈希表时，我们面临着一个重要的问题，即哈希冲突。哈希冲突发生在不同的键映射到相同的哈希桶位置时，这可能导致数据的丢失或者影响哈希表的性能。因此，解决哈希冲突是构建高效、稳定哈希表的关键一环。在面对哈希冲突时，我们需要采用一些巧妙的方法来保证数据的唯一性、高效的查找和插入操作。下面将介绍几种常见的解决哈希冲突的方法，包括开放寻址法、链地址法以及其他一些策略。

正文

哈希冲突的解决方法主要分为两大类：开放寻址法和链地址法。以下是这两大类中的一些具体方法：

1. 开放寻址法（Open Addressing）：

• 线性探测（Linear Probing）： 如果哈希桶中的位置已经被占用，就线性地往后寻找下一个可用的位置。
• 二次探测（Quadratic Probing）： 在发生冲突时，通过二次方程来寻找下一个可用的位置，以减小探测的步长。
• 双重散列（Double Hashing）： 使用两个哈希函数，如果发生冲突，就通过第二个哈希函数来计算下一个位置。

代码 ：

public class LinearProbingHashTable {
    private int size;
    private String[] table;

    public LinearProbingHashTable(int capacity) {
        size = 0;
        table = new String[capacity];
    }

    public void insert(String key) {
        int index = hashFunction(key);
        while (table[index] != null) {
            index = (index + 1) % table.length; // 线性探测
        }
        table[index] = key;
        size++;
    }

    public boolean search(String key) {
        int index = hashFunction(key);
        while (table[index] != null) {
            if (table[index].equals(key)) {
                return true;
            }
            index = (index + 1) % table.length; // 线性探测
        }
        return false;
    }

    private int hashFunction(String key) {
        // 实现哈希函数的逻辑
        return key.hashCode() % table.length;
    }
}

2. 链地址法（Chaining）：

• 基本链地址法： 哈希桶中的每个位置都是一个链表的头节点，当发生冲突时，将新的元素添加到链表中。
• 使用平衡树的链地址法： 链表可以替换成平衡二叉树或其他数据结构，以提高性能。
• Cuckoo Hashing： 使用两个哈希函数和两个哈希表，当发生冲突时，按照两个哈希函数的结果在两个表中进行插入，如果产生循环则重新哈希。

代码 

import java.util.LinkedList;

public class ChainingHashTable {
    private int size;
    private LinkedList<String>[] table;

    public ChainingHashTable(int capacity) {
        size = 0;
        table = new LinkedList[capacity];
        for (int i = 0; i < capacity; i++) {
            table[i] = new LinkedList<>();
        }
    }

    public void insert(String key) {
        int index = hashFunction(key);
        table[index].add(key);
        size++;
    }

    public boolean search(String key) {
        int index = hashFunction(key);
        return table[index].contains(key);
    }

    private int hashFunction(String key) {
        // 实现哈希函数的逻辑
        return key.hashCode() % table.length;
    }
}

 

3. 其他方法：

再哈希（Rehashing）：

当哈希表达到一定的负载因子时，扩展哈希表的大小，然后重新哈希已有的元素。

代码：

import java.util.Arrays;

public class RehashingHashTable {
    private static final double LOAD_FACTOR_THRESHOLD = 0.7;
    private int size;
    private String[] table;

    public RehashingHashTable(int initialCapacity) {
        size = 0;
        table = new String[initialCapacity];
    }

    public void insert(String key) {
        if ((double) size / table.length > LOAD_FACTOR_THRESHOLD) {
            rehash();
        }

        int index = hashFunction(key);
        while (table[index] != null) {
            index = (index + 1) % table.length;
        }
        table[index] = key;
        size++;
    }

    private void rehash() {
        int newCapacity = table.length * 2;
        String[] newTable = new String[newCapacity];

        for (String key : table) {
            if (key != null) {
                int index = hashFunction(key);
                while (newTable[index] != null) {
                    index = (index + 1) % newTable.length;
                }
                newTable[index] = key;
            }
        }

        table = newTable;
    }

    private int hashFunction(String key) {
        // 实现哈希函数的逻辑
        return key.hashCode() % table.length;
    }
}

完全随机化哈希函数：

通过使用随机化的哈希函数来减小冲突的概率。

代码：

import java.util.Random;

public class RandomizedHashFunction {
    private static final int PRIME_NUMBER = 31; // 用于构建复杂哈希函数的质数
    private int size;
    private String[] table;

    public RandomizedHashFunction(int capacity) {
        size = 0;
        table = new String[capacity];
    }

    public void insert(String key) {
        int index = randomizedHashFunction(key);
        while (table[index] != null) {
            index = (index + 1) % table.length;
        }
        table[index] = key;
        size++;
    }

    private int randomizedHashFunction(String key) {
        Random random = new Random();
        int hash = 0;
        for (char c : key.toCharArray()) {
            hash = (hash * PRIME_NUMBER + c) % table.length;
        }
        return hash;
    }
}

哈希桶分割：

将哈希表分成若干个桶，每个桶都是一个小的哈希表，可以独立进行扩展和收缩。

代码：

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

public class HashBucketSplitting {
    private List<String>[] buckets;
    private static final int INITIAL_BUCKET_COUNT = 10;

    public HashBucketSplitting() {
        buckets = new List[INITIAL_BUCKET_COUNT];
        for (int i = 0; i < INITIAL_BUCKET_COUNT; i++) {
            buckets[i] = new ArrayList<>();
        }
    }

    public void insert(String key) {
        int index = hashFunction(key);
        buckets[index].add(key);
    }

    public boolean search(String key) {
        int index = hashFunction(key);
        return buckets[index].contains(key);
    }

    private int hashFunction(String key) {
        // 实现哈希函数的逻辑
        return key.hashCode() % buckets.length;
    }
}

选择哪种方法取决于具体的应用场景、性能需求和数据特性。每种方法都有其优势和劣势，需要根据具体情况进行选择。

结语

        解决哈希冲突是哈希表设计中不可忽视的重要问题。选择合适的冲突解决策略直接影响了哈希表的性能和稳定性。开放寻址法通过在哈希表中寻找新的空位置来解决冲突，而链地址法则通过在冲突位置构建链表等数据结构来存储冲突的元素。另外，再哈希、完全随机化哈希函数和哈希桶分割等方法也为我们提供了在不同场景下解决哈希冲突的有效手段。

 我的其他博客

【MySQL】数据库规范化的三大法则 — 一探范式设计原则-程序员宅基地

【JAVA】线程的run()和start()有什么区别？-程序员宅基地

【日常聊聊】程序员必备的面试技巧：如何在面试战场上脱颖而出-程序员宅基地

【JAVA】Java8开始ConcurrentHashMap,为什么舍弃分段锁-程序员宅基地

【JAVA】怎么确保一个集合不能被修改-程序员宅基地

【Web开发】会话管理与无 Cookie 环境下的实现策略-程序员宅基地

【Mybatis】Mybatis如何防止sql注入-程序员宅基地

【软件工程】航行敏捷之路：深度解析Scrum框架的精髓-程序员宅基地

【Spring】理解IoC与AOP：构建灵活而模块化的软件架构-程序员宅基地