哈希数据结构的增强

1. 背景

哈希作为一种常用的数据结构,key-value 的读写都很有着很高的性能,时间复杂度 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1)。但也存在着一些限制,比如:

  • 关于哈希的遍历都是无序的,所以每次遍历的结果都不一样。
  • 怎么做到随机返回哈希中的一对 key-value,要求时间复杂度 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1),而且是均匀的。

现在我们就针对这 2 个问题讨论下怎么设计。

2. 链表加强哈希,实现遍历有序

思路:

  • 继续使用哈希数据结构存储 key-value,毕竟这是最高效的
  • 如何保证有序:使用双向链表
    • 添加 key-value 时,将 key-value 添加在链表的头部,当然也可能是移动到链表头部。
    • 删除 key-value 时,将 key-value 从链表中删除。
    • 遍历时,从链表的头部开始直到链表的尾部,因为链表的遍历是有序的,所以整个遍历结果也是有序的。
Golang 复制代码
type Node[K comparable, T any] struct {

    key K

    value T

    next *Node[K, T]

    prev *Node[K, T]

}


type LinkedList[K comparable, T any] interface {

    MoveToHead(node Node[K, T])

    AddToHead(node Node[K, T])

    DeleteNode(node Node[K, T])

    Next() Node[K, T]

    HasNext() bool

}



type HashSet[K comparable, T any] struct {

    linkedList LinkedList[K, T]

    keyNode map[K]*Node[K, T]

}

  


func (h *HashSet[K, T]) Get(key K) (T, error) {

    var value T

    node, ok := h.keyNode[key]

    if !ok {

        return value, errors.New("key not found")

    }

    return node.value, nil

}


func (h *HashSet[K, T]) Set(key K, value T) error {

    node, ok := h.keyNode[key]

    if ok {

        node.value = value

        h.linkedList.MoveToHead(*node)

        return nil

    }

    node = &Node[K, T]{key: key, value: value, prev: nil, next: nil}

    h.keyNode[key] = node

    h.linkedList.AddToHead(*node)

    return nil

}

 

func (h *HashSet[K, T]) Delete(key K) error {

    node, ok := h.keyNode[key]

    if !ok {

        return errors.New("key not found")

    }

    delete(h.keyNode, key)

    h.linkedList.DeleteNode(*node)

    return nil

}


type procFunc[K comparable, T any] func(key K, value T)
  

func (h *HashSet[K, T]) iterator(proc procFunc[K, T]) {

    for h.linkedList.HasNext() {

        node := h.linkedList.Next()

        proc(node.key, node.value)

    }

}

时间复杂度并没有增加,读写依旧是 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1),空间复杂度比普通哈希数据结构翻倍。

3. 数组加强哈希,实现 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 1 ) O(1) </math>O(1) 复杂度随机返回一对 key-value

思路:

  • 标准数组可以实现 O(1) 复杂度在随机生成一个 [0, size) 的索引。

  • 基于拉链法实现的哈希,虽然本质使用了一个数组,但每一个数组都都是一个指向头节点的链表。不知道数组的长度,也不知道每一个链表的长度。必然需要先遍历才能实现返回一对随机的 key-value,时间复杂度不满足。

  • 基于线性探测法,可能存在空洞,每一对 key-value 返回的概率不等。

    • 向左或向右查找,找到第一个非空元素。时间复杂度不满足,不是均匀随机的,沿固定方向查找会导致某一侧元素被选中的概率增大。
    • 多次随机------遇到空洞就再随机生成一个索引,这样做是均匀的,但是时间复杂度不满足。
  • 基于标准哈希 + 数组实现

    • 哈希的 value 是数组的索引。
    • 添加一对 key-value 就在数组后面添加一个元素。
    • 删除一对 key-value 需要在数据中删除对应的元素,但我们可以简化操作,将最后一个元素替换到删除的索引,然后将数据的长度剪 1。
goland 复制代码
type array[T any] []T


func (a array[T]) pop() {

    size := len(a)

    if size == 0 {

        return

    }

    newArray := make([]T, size-1)

    copy(newArray, a[0:size-1])

    a = newArray

}


type HashSet[K comparable, T any] struct {

    values array[T]

    indexes map[K]int

}


func (h *HashSet[K, T]) Get(key K) (T, error) {

    var value T

    index, ok := h.indexes[key]

    if !ok {

        return value, errors.New("key not found")

    }

    value = h.values[index]

    return value, nil

}


func (h *HashSet[K, T]) Set(key K, value T) {

    index, ok := h.indexes[key]

    if ok {

        h.values[index] = value

    return

    }


    index = len(h.values)

    h.values = append(h.values, value)

    h.indexes[key] = index

}


func (h *HashSet[K, T]) Delete(key K) error {

    index, ok := h.indexes[key]

    if !ok {

        return errors.New("key not found")

    }

  
    lastIndex := len(h.indexes) - 1

    // 交换 value

    h.values[index], h.values[lastIndex] = h.values[lastIndex], h.values[index]

    // 删除最后一个元素。可优化,删除大量元素后,再缩容

    h.values.pop()

    // 删除 key

    delete(h.indexes, key)

    return nil

}


func (h *HashSet[K, T]) Random() T {

    size := len(h.indexes)

    index := rand.Intn(size)

    return h.values[index]

}
相关推荐
张人玉1 小时前
C# 常量与变量
java·算法·c#
weixin_446122462 小时前
LinkedList剖析
算法
百年孤独_3 小时前
LeetCode 算法题解:链表与二叉树相关问题 打打卡
算法·leetcode·链表
风飘百里3 小时前
分组加密核心原理与实践解析(AES/SM4)
go
我爱C编程3 小时前
基于拓扑结构检测的LDPC稀疏校验矩阵高阶环检测算法matlab仿真
算法·matlab·矩阵·ldpc·环检测
算法_小学生3 小时前
LeetCode 75. 颜色分类(荷兰国旗问题)
算法·leetcode·职场和发展
运器1233 小时前
【一起来学AI大模型】算法核心:数组/哈希表/树/排序/动态规划(LeetCode精练)
开发语言·人工智能·python·算法·ai·散列表·ai编程
算法_小学生3 小时前
LeetCode 287. 寻找重复数(不修改数组 + O(1) 空间)
数据结构·算法·leetcode
岁忧3 小时前
(LeetCode 每日一题) 1865. 找出和为指定值的下标对 (哈希表)
java·c++·算法·leetcode·go·散列表
alphaTao3 小时前
LeetCode 每日一题 2025/6/30-2025/7/6
算法·leetcode·职场和发展