学习数据结构的三个阶段

1、掌握基本用法：使用这些数据结构解决一些基本问题。

2、应用场景选择：知道在何种场景下选用哪种数据结构。

3、深入理解实现：了解内置数据结构的源码实现，并将其与相关算法知识联系起来，提升编程能力。

10 种常用的数据结构

1、List (列表)

• 基本用法：list 是 Python 中最基本的数据结构，允许存储多个值且支持动态大小。
• 使用场景：适合频繁查询和修改：例如，在需要按索引访问元素时，list 的性能优越。不适合频繁插入和删除：特别是在开头插入或删除时，因为这样会导致后面的元素都要移动。
• 实现原理：list 底层是动态数组，初始状态下无需指定长度。当插入元素超过初始容量时，会进行扩容，通常是以两倍的方式增加大小。删除操作尤其在列表开头执行时，由于涉及大量元素的位移，因此时间复杂度为 O(n)。

# 创建一个列表
fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 输出：apple

# 添加元素
fruits.append('orange')
print(fruits)  # 输出：['apple', 'banana', 'cherry', 'orange']

# 修改元素
fruits[1] = 'kiwi'
print(fruits)  # 输出：['apple', 'kiwi', 'cherry', 'orange']

# 删除元素
fruits.remove('cherry')
print(fruits)  # 输出：['apple', 'kiwi', 'orange']

2、Tuple (元组)

• 基本用法：tuple 是一种不可变的序列，一旦创建便无法修改。
• 使用场景：确保数据不被修改：如果确定对象不会被修改（比如坐标），可以使用元组。节省内存：由于元组的不可变性，Python 在内存管理上更高效。
• 实现原理：tuple 是一种静态数组，不支持动态扩展，其存储方式相较于 list 更加紧凑，因此在同等条件下占用的内存更少。

# 创建一个元组
coordinates = (10, 20)
print(coordinates[0])  # 输出：10

# 元组解包
x, y = coordinates
print(x, y)  # 输出：10 20

from sys import getsizeof
print(getsizeof(list()))  # 输出：72
print(getsizeof(tuple()))  # 输出：56

3、Set (集合)

• 基本用法：set 是一种无序且不重复的集合，主要用于去重和集合运算。
• 使用场景：去除重复元素。快速查找：适合快速判断某个元素是否存在。
• 实现原理：set 通过哈希表实现，采用哈希函数将元素映射到固定的索引，增删查操作平均时间复杂度为 O(1)，因此效率极高。

# 创建一个集合
a = [3, 2, 5, 2, 5, 3]
unique_values = set(a)
print(unique_values)  # 输出：{2, 3, 5}

# 集合操作
b = {3, 4, 6, 2}
intersection = unique_values.intersection(b)  # 求交集
print(intersection)  # 输出：{2, 3}

4、Dict (字典)

• 基本用法：dict 是基于键-值对数据结构，广泛用于数据存储和检索。
• 使用场景：高效查询：适合需要快速查找的场景，如用户信息存储。统计数据：比如计算字符串中字符出现次数的场景。
• 实现原理：dict 实际上是哈希表实现，基于键值对存储数据，查找、插入和删除操作的平均时间复杂度是 O(1)。不过，由于哈希表的设计，字典在内存上相对消耗较大。

# 创建字典
d = {'a': 1, 'b': 2}
print(d['a'])  # 输出：1

# 添加元素
d['c'] = 3
print(d)  # 输出：{'a': 1, 'b': 2, 'c': 3}

# 修改元素
d['b'] = 5
print(d)  # 输出：{'a': 1, 'b': 5, 'c': 3}

# 删除元素
del d['a']
print(d)  # 输出：{'b': 5, 'c': 3}

text = "hello world"
count_dict = {}
for char in text:
    count_dict[char] = count_dict.get(char, 0) + 1
print(count_dict)  # 输出：{'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

5、Deque (双端队列)

• 基本用法：deque 是双端队列，支持从左右两边高效地添加和删除元素。
• 使用场景：需要频繁在两端进行操作的场景：如任务调度、回溯算法等
• 实现原理：deque 是一个双向链表，因此在两端进行操作时，时间复杂度都是 O(1)。它内部维护了一个数组和链表的数据结构，使得存取操作灵活且高效。

from collections import deque

# 创建一个双端队列
d = deque([3, 2, 4])
d.appendleft(1)  # 从左侧添加元素
print(d)  # 输出：deque([1, 3, 2, 4])

# 从右侧添加元素
d.append(5)
print(d)  # 输出：deque([1, 3, 2, 4, 5])

# 从左侧删除元素
d.popleft()
print(d)  # 输出：deque([3, 2, 4, 5])

6、Counter (计数器)

• 基本用法：Counter 是用于计数的容器，可以轻松统计元素出现的频率。
• 使用场景：统计频次：分析文本数据、用户行为等，找出最常见的项。
• 实现原理：Counter 继承自 dict，其实现简单明了，将元素作为键，出现的次数作为值，方便快速统计和查询。

from collections import Counter

# 创建 Counter
c = Counter(['apple', 'orange', 'apple', 'banana'])
print(c)  # 输出：Counter({'apple': 2, 'orange': 1, 'banana': 1})

# 获取最常见的元素
most_common = c.most_common(2)  # 前两个常见元素
print(most_common)  # 输出：[('apple', 2), ('orange', 1)]

7、OrderedDict (有序字典)

• 基本用法：OrderedDict 是一个保持插入顺序的字典。
• 使用场景：需要保持元素插入顺序的场景：如任务调度、配置文件解析等。
• 实现原理：OrderedDict 内部维护了一个双向链表来记录元素的插入顺序，同时还能保证 O(1) 的插入、删除和查找效率。

from collections import OrderedDict

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3

for k, v in od.items():
    print(k, v)  # 输出：a 1, b 2, c 3

8、Heapq (堆队列)

• 基本用法：heapq 提供了堆队列算法，支持高效的优先级队列实现。
• 使用场景：需要经常获取最小或最大值的场景：如实时数据处理、任务调度等。
• 实现原理：堆是一种特殊的完全二叉树，其中父节点的值小于子节点（最小堆）。heapq 模块使用数组实现堆，能够很方便地维持堆的性质。

import heapq

a = [3, 1, 4, 2]
heapq.heapify(a)  # 建堆
print(a[0])  # 输出：1，最小元素

# 获取前 3 个最大元素
largest = heapq.nlargest(3, a)
print(largest)  # 输出：[4, 3, 2]

# 获取前 3 个最小元素
smallest = heapq.nsmallest(3, a)
print(smallest)  # 输出：[1, 2, 3]

9、Defaultdict (默认字典)

• 基本用法：defaultdict 是一种带默认值的字典，避免了键不存在时的 KeyError。
• 使用场景：适合需要自动初始化的字典：如频率统计、分组归类等场景。
• 实现原理：defaultdict 是对 dict 的扩展，当访问一个未定义的键时，会调用默认工厂函数生成一个默认值，避免了显式的检查。

from collections import defaultdict

d = defaultdict(int)  # 默认值为 0
d['apple'] += 1
d['banana'] += 2
print(d)  # 输出：defaultdict(<class 'int'>, {'apple': 1, 'banana': 2})

# 添加列表作为默认值
dd = defaultdict(list)
words = ['book', 'nice', 'great', 'book']
for i, word in enumerate(words):
    dd[word].append(i)
print(dd)  # 输出：defaultdict(<class 'list'>, {'book': [0, 3], 'nice': [1], 'great': [2]})

10、ChainMap (链式映射)

• 基本用法：ChainMap 用于将多个字典组合为一个字典视图，支持同时查找。
• 使用场景：合并多个字典并希望同步更改的场景：如配置文件管理、环境变量设置等。
• 实现原理：ChainMap 将多个字典视为一个单一的映射，每次查找首先会检查第一个字典，如果没有找到，再查找下一个，这使得多个字典的合并变得简单而高效。

from collections import ChainMap

d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
cm = ChainMap(d1, d2)

print(cm['b'])  # 输出：2，取自 d1
print(cm['c'])  # 输出：4，取自 d2

# 修改键值对
cm['b'] = 5
print(d1)  # 输出：{'a': 1, 'b': 5}, d1 被修改

总结

本文介绍了List (列表)、Tuple (元组)、Set (集合)、Dict (字典)、Deque (双端队列)、Counter (计数器)、OrderedDict (有序字典)、Heapq (堆队列)、Defaultdict (默认字典)、ChainMap (链式映射)十种常见的Python数据结构以及实际场景使用，希望能让你对数据结构有一个好的理解。