python
复制代码
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
文件名: data_structures.py
开发思路和开发过程:
1. 首先介绍线性数据结构：数组、栈、队列
2. 然后介绍非线性数据结构：链表、树、图
3. 接着介绍哈希表和集合
4. 最后演示Python内置数据结构的使用技巧
代码功能: 演示Python中常见数据结构的实现和使用方法，包括列表、栈、队列、链表、树等。
"""
print("=== Python 数据结构示例 ===\n")
# 1. 线性数据结构
print("1. 线性数据结构:")
# 1.1 数组（在Python中使用列表模拟）
print("1.1 数组（列表）:")
arr = [1, 2, 3, 4, 5]
print(f"创建数组: {arr}")
print(f"访问元素 arr[2]: {arr[2]}")
arr[2] = 10
print(f"修改元素后: {arr}")
print(f"数组长度: {len(arr)}")
# 1.2 栈（Stack）- 后进先出(LIFO)
print("\n1.2 栈（Stack）:")
stack = [] # 使用列表模拟栈
# 入栈（push）
stack.append(1)
stack.append(2)
stack.append(3)
print(f"入栈后: {stack}")
# 出栈（pop）
popped_element = stack.pop()
print(f"出栈元素: {popped_element}")
print(f"出栈后: {stack}")
# 查看栈顶元素
top_element = stack[-1]
print(f"栈顶元素: {top_element}")
# 1.3 队列（Queue）- 先进先出(FIFO)
print("\n1.3 队列（Queue）:")
from collections import deque
queue = deque() # 使用deque实现高效队列
# 入队（enqueue）
queue.append(1)
queue.append(2)
queue.append(3)
print(f"入队后: {list(queue)}")
# 出队（dequeue）
dequeued_element = queue.popleft()
print(f"出队元素: {dequeued_element}")
print(f"出队后: {list(queue)}")
print()
# 2. 链表（Linked List）
print("2. 链表（Linked List）:")
class ListNode:
"""链表节点类"""
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def __str__(self):
return str(self.val)
class LinkedList:
"""链表类"""
def __init__(self):
self.head = None
def append(self, val):
"""在链表末尾添加节点"""
new_node = ListNode(val)
if not self.head:
self.head = new_node
return
current = self.head
while current.next:
current = current.next
current.next = new_node
def prepend(self, val):
"""在链表头部添加节点"""
new_node = ListNode(val)
new_node.next = self.head
self.head = new_node
def delete(self, val):
"""删除指定值的节点"""
if not self.head:
return
if self.head.val == val:
self.head = self.head.next
return
current = self.head
while current.next:
if current.next.val == val:
current.next = current.next.next
return
current = current.next
def display(self):
"""显示链表内容"""
elements = []
current = self.head
while current:
elements.append(str(current.val))
current = current.next
return " -> ".join(elements)
# 使用链表示例
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
print(f"创建链表: {ll.display()}")
ll.prepend(0)
print(f"头部插入0后: {ll.display()}")
ll.delete(2)
print(f"删除2后: {ll.display()}")
print()
# 3. 树（Tree）
print("3. 树（Tree）:")
class TreeNode:
"""树节点类"""
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def inorder_traversal(root):
"""中序遍历（左-根-右）"""
result = []
if root:
result.extend(inorder_traversal(root.left))
result.append(root.val)
result.extend(inorder_traversal(root.right))
return result
def preorder_traversal(root):
"""前序遍历（根-左-右）"""
result = []
if root:
result.append(root.val)
result.extend(preorder_traversal(root.left))
result.extend(preorder_traversal(root.right))
return result
def postorder_traversal(root):
"""后序遍历（左-右-根）"""
result = []
if root:
result.extend(postorder_traversal(root.left))
result.extend(postorder_traversal(root.right))
result.append(root.val)
return result
# 构建示例二叉树:
# 1
# / \
# 2 3
# / \
# 4 5
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
print("构建二叉树:")
print(" 1")
print(" / \\")
print(" 2 3")
print(" / \\")
print(" 4 5")
print(f"中序遍历: {inorder_traversal(root)}") # 4, 2, 5, 1, 3
print(f"前序遍历: {preorder_traversal(root)}") # 1, 2, 4, 5, 3
print(f"后序遍历: {postorder_traversal(root)}") # 4, 5, 2, 3, 1
print()
# 4. 哈希表（Hash Table）
print("4. 哈希表（Hash Table）:")
# Python中的字典就是哈希表的实现
hash_table = {}
# 插入键值对
hash_table["name"] = "张三"
hash_table["age"] = 25
hash_table["city"] = "北京"
print(f"哈希表内容: {hash_table}")
# 访问值
print(f"姓名: {hash_table['name']}")
# 更新值
hash_table["age"] = 26
print(f"更新年龄后: {hash_table}")
# 删除键值对
del hash_table["city"]
print(f"删除城市后: {hash_table}")
# 检查键是否存在
if "name" in hash_table:
print(f"存在键 'name'，值为: {hash_table['name']}")
print()
# 5. 集合（Set）
print("5. 集合（Set）:")
# 创建集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(f"集合1: {set1}")
print(f"集合2: {set2}")
# 集合操作
print(f"并集: {set1 | set2}") # 或者 set1.union(set2)
print(f"交集: {set1 & set2}") # 或者 set1.intersection(set2)
print(f"差集 (set1 - set2): {set1 - set2}") # 或者 set1.difference(set2)
print(f"对称差集: {set1 ^ set2}") # 或者 set1.symmetric_difference(set2)
# 添加和删除元素
set1.add(6)
print(f"添加6后集合1: {set1}")
set1.remove(1)
print(f"删除1后集合1: {set1}")
print()
# 6. 堆（Heap）
print("6. 堆（Heap）:")
import heapq
# 创建最小堆
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 4)
heapq.heappush(heap, 2)
print(f"创建最小堆: {heap}")
# 弹出最小元素
min_element = heapq.heappop(heap)
print(f"弹出最小元素: {min_element}")
print(f"弹出后堆: {heap}")
# 将列表转换为堆
numbers = [5, 2, 8, 1, 9]
heapq.heapify(numbers)
print(f"将列表转换为堆: {numbers}")
print()
# 7. 高级数据结构使用技巧
print("7. 高级数据结构使用技巧:")
# 7.1 使用collections.defaultdict避免键不存在的错误
from collections import defaultdict
# 普通字典在键不存在时会报错
normal_dict = {}
# normal_dict['key'].append(1) # 这会报错
# defaultdict在键不存在时会自动创建默认值
default_dict = defaultdict(list)
default_dict['key'].append(1)
print(f"defaultdict示例: {dict(default_dict)}")
# 7.2 使用collections.Counter计数
from collections import Counter
text = "hello world"
char_count = Counter(text)
print(f"字符计数: {dict(char_count)}")
print(f"最常见的2个字符: {char_count.most_common(2)}")
# 7.3 使用namedtuple创建具名元组
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p1 = Point(1, 2)
p2 = Point(3, 4)
print(f"创建点p1: x={p1.x}, y={p1.y}")
print(f"创建点p2: x={p2.x}, y={p2.y}")
print("\n=== 数据结构示例结束 ===")