Python 中的各种数据结构

Python 中的基础数据结构

列表（List）

列表是Python中最常用的数据结构之一，用于存储一系列有序的元素。以下是一些基本操作：

# 创建列表
my_list = [1, 2, 3, 4, 5]

# 访问元素
print(my_list[0])  # 输出：1

# 切片
subset = my_list[1:4]  # 输出：[2, 3, 4]

# 修改元素
my_list[2] = 6

# 添加元素
my_list.append(7)

# 删除元素
del my_list[1]

元组（Tuple）

元组与列表类似，但是元组是不可变的。这意味着一旦创建，元组的内容就无法修改。

# 创建元组
my_tuple = (1, 2, 3, 4, 5)

# 访问元素
print(my_tuple[0])  # 输出：1

# 切片
subset = my_tuple[1:4]  # 输出：(2, 3, 4)

集合（Set）

集合是一种无序且不重复的数据结构，用于存储唯一的元素。

# 创建集合
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(2)

# 集合运算
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2  # 并集
intersection_set = set1 & set2  # 交集

字典（Dictionary）

字典是一种键值对的数据结构，用于存储和检索具有唯一标识符的值。

# 创建字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 访问元素
print(my_dict['a'])  # 输出：1

# 修改元素
my_dict['b'] = 4

# 添加元素
my_dict['d'] = 5

# 删除元素
del my_dict['c']

Python 中的高级数据结构

堆（Heap）

堆是一种特殊的树形数据结构，通常用于实现优先队列。

import heapq

# 创建堆
my_heap = [1, 3, 5, 7, 9]
heapq.heapify(my_heap)

# 添加元素
heapq.heappush(my_heap, 2)

# 弹出最小元素
min_element = heapq.heappop(my_heap)

队列（Queue）

队列是一种先进先出（FIFO）的数据结构，常用于任务调度等场景。

from queue import Queue

# 创建队列
my_queue = Queue()

# 入队
my_queue.put(1)
my_queue.put(2)

# 出队
first_element = my_queue.get()

栈（Stack）

栈是一种后进先出（LIFO）的数据结构，通常用于递归、表达式求值等场景。

# 创建栈
my_stack = []

# 入栈
my_stack.append(1)
my_stack.append(2)

# 出栈
top_element = my_stack.pop()

链表（Linked List）

链表是一种线性数据结构，由节点组成，每个节点包含数据和指向下一个节点的引用。链表可以分为单向链表和双向链表。

# 单向链表节点
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 创建链表
node1 = Node(1)
node2 = Node(2)
node3 = Node(3)

node1.next = node2
node2.next = node3

树（Tree）

树是一种层级结构的数据结构，由节点组成，每个节点可以有零个或多个子节点。

# 二叉树节点
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

# 创建二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

图（Graph）

图是由节点和边组成的数据结构，节点表示实体，边表示节点之间的关系。图可以分为有向图和无向图。

# 有向图的表示
graph = {'A': ['B', 'C'],
         'B': ['D', 'E'],
         'C': ['F'],
         'D': [],
         'E': ['F'],
         'F': []}

字典树（Trie）

字典树是一种树形数据结构，用于存储动态集合或关联数组，常用于字符串检索操作。

# Trie节点
class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_of_word = False

# 创建Trie
trie_root = TrieNode()
trie_root.children['a'] = TrieNode()
trie_root.children['a'].children['p'] = TrieNode()
trie_root.children['a'].children['p'].is_end_of_word = True

Python 中的其他常用数据结构

哈希表（Hash Table）

哈希表是一种通过哈希函数将键映射到索引的数据结构，常用于实现字典和集合。

# 创建哈希表
my_dict = {}
my_dict['a'] = 1
my_dict['b'] = 2

布隆过滤器（Bloom Filter）

布隆过滤器是一种空间效率高、快速判定元素是否属于一个集合的概率型数据结构。

from pybloom_live import BloomFilter

# 创建布隆过滤器
my_filter = BloomFilter(capacity=1000, error_rate=0.001)

# 添加元素
my_filter.add('example')

# 判断元素是否存在
is_exists = 'example' in my_filter

计数器（Counter）

计数器是Python中的一种集合数据类型，用于统计可哈希对象的数量。

from collections import Counter

# 创建计数器
my_counter = Counter(['apple', 'banana', 'apple', 'orange'])

# 统计元素数量
count_apple = my_counter['apple']  # 输出：2

堆栈（Deque）

堆栈是一种双端队列，支持从两端添加和弹出元素，常用于实现先进先出（FIFO）和后进先出（LIFO）操作。

from collections import deque

# 创建堆栈
my_stack = deque()

# 入栈
my_stack.append(1)

# 出栈
top_element = my_stack.pop()