字典，哈希表和关联数组_关联数组和字典-CSDN博客

本文链接：https://blog.csdn.net/mihengZB/article/details/143728997

字典、哈希表和关联数组：它们有何区别？

乍一看，字典、哈希表和关联数组似乎说的是同一件事。如果你也有这样的疑问，那么这篇文章将会帮助你澄清这些概念之间的区别。

字典

字典是一种抽象数据类型（ADT），它描述了一种数据结构应提供的功能。字典存储的是键值对，每个键都是唯一的，用于查找对应的值。这种概念类似于现实生活中的字典，通过单词（键）查找其定义（值）。

哈希表

哈希表是一种具体的数据结构，用于实现字典的功能。它通过一个哈希函数将键映射到表中的位置，从而实现高效的插入、删除和查找操作。哈希表的核心在于哈希函数的设计和冲突解决机制。

关联数组

关联数组是对字典的另一种解释，通常指的是一种以键值对形式存储数据的数据结构。它可以使用非整数作为索引来访问元素。虽然“关联数组”和“字典”这两个术语经常互换使用，但“字典”更为通用，而“关联数组”更强调其键值对的形式。

总结

字典：一种抽象的概念，描述了一种数据结构应提供的功能。
哈希表：实现字典功能的具体方法之一。
关联数组：字典的另一种叫法，强调其键值对的形式。

简而言之，字典是一种抽象的概念，哈希表是实现这些功能的具体方法，而关联数组则是字典的另一种表述方式。

抽象层次

1. 语言级别的抽象

抽象层次：

高级抽象：编程语言提供了高度抽象的数据结构，使得开发者可以直接使用而无需关心底层细节。
低级抽象：开发者需要自己管理和控制数据结构的内部工作方式。

示例：

Python (高级抽象):
- 字典: Python 中的 dict 是一种字典类型的集合，允许使用任意不可变类型作为键。
```
my_dict = {'apple': 1, 'banana': 2}
print(my_dict['apple'])  # 输出: 1
```
- 内部实现: 虽然 Python 的 dict 内部使用了哈希表来实现高效的查找、插入和删除操作，但这些细节对用户来说是透明的。
C++ (低级抽象):
- 标准模板库 (STL) 中的 std::unordered_map: 这是一个基于哈希表实现的关联容器，提供了键值对的存储和检索功能。
```
#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int> my_map;
    my_map["apple"] = 1;
    my_map["banana"] = 2;
    std::cout << my_map["apple"] << std::endl;  // 输出: 1
    return 0;
}
```
- 内部实现: 在 C++ 中，std::unordered_map 的内部实现细节可以通过文档查看，但通常不需要开发者直接管理这些细节。

2. 数据结构的实现

抽象层次：

黑盒实现: 用户只需要知道如何使用数据结构，而不需要了解其内部工作机制。
白盒实现: 用户不仅知道如何使用数据结构，还需要了解其内部细节，并可能需要进行优化或调试。

示例：

Java (黑盒实现):

HashMap: Java 中的 HashMap 类提供了字典的功能，内部使用哈希表实现。

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("apple", 1);
        map.put("banana", 2);
        System.out.println(map.get("apple"));  // 输出: 1
    }
}

内部实现: HashMap 的内部实现细节对大多数开发者来说是透明的，除非他们需要深入研究性能问题。

C (白盒实现):

自定义哈希表: 在 C 语言中，如果需要一个哈希表，开发者通常需要自己实现。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char *key;
    int value;
} KeyValuePair;

typedef struct {
    KeyValuePair *table;
    int capacity;
} HashTable;

unsigned int hash(const char *key, int capacity) {
    unsigned int hash = 0;
    while (*key) {
        hash = (hash << 5) + hash + *key++;
    }
    return hash % capacity;
}

void insert(HashTable *ht, const char *key, int value) {
    int index = hash(key, ht->capacity);
    ht->table[index].key = strdup(key);
    ht->table[index].value = value;
}

int get(HashTable *ht, const char *key) {
    int index = hash(key, ht->capacity);
    return ht->table[index].value;
}

int main() {
    HashTable ht = {NULL, 10};
    ht.table = malloc(ht.capacity * sizeof(KeyValuePair));

    insert(&ht, "apple", 1);
    insert(&ht, "banana", 2);

    printf("%d\n", get(&ht, "apple"));  // 输出: 1

    free(ht.table);
    return 0;
}

内部实现: 在这个例子中，开发者需要详细管理哈希函数、内存分配和碰撞处理等细节。

3. 编程实践中的应用

抽象层次：

简单使用: 只需要调用预定义的方法来使用数据结构。
复杂使用: 需要理解和调整数据结构的内部行为，以适应特定的需求。

示例：

JavaScript (简单使用):

对象: JavaScript 中的对象可以当作关联数组使用。

let obj = { apple: 1, banana: 2 };
console.log(obj.apple);  // 输出: 1

Map 对象: ES6 引入的 Map 对象提供了更多的功能，如迭代器。

let map = new Map();
map.set('apple', 1);
map.set('banana', 2);
console.log(map.get('apple'));  // 输出: 1

Rust (复杂使用):

HashMap: Rust 标准库中的 HashMap 提供了丰富的功能，但使用时需要注意所有权和生命周期等概念。

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(String::from("apple"), 1);
    map.insert(String::from("banana"), 2);
    println!("{}", map[&String::from("apple")]);  // 输出: 1
}

内部实现: 在 Rust 中，HashMap 的使用需要考虑内存安全和并发安全，这增加了使用的复杂性。

一些经验分享

通过这些例子，可以看到不同编程语言在不同抽象层次上对字典、哈希表和关联数组的支持和实现方式。不同的语言会提供不同的抽象（从这一点看学习不同的语言不就是学这些不同的抽象嘛，嗯，挺有意思的）。

同时，不仅是字典这种抽象概念，另外还有集合，队列，栈这些抽象数据类型，从最低级的C语言开始，应该怎么一步步实现这些功能的，再到C++，它又提供了哪些抽象，在标准库STL中有哪些相关的实现，再到Java，python，它们是怎么抽象和封装这些数据结构的。当你开始从不同语言的视角来看待这些问题，我相信数据结构就没什么难的了，无所遁形。