一、图结构与树形数据的基础概念
在Python中，图和树是一种非常重要的非线性数据结构。简单来说，图是由节点（Node）和边（Edge）组成的集合，而树**是图的一种特殊形式，具有层级关系。
举个例子：假设你有一个家族谱系，每个人是一个节点，父子关系是边，这就是一棵树！再比如社交网络中，人与人之间的朋友关系可以看作是一个图。
树的基本术语：
- 根节点（Root）：树的起点。
- 子节点（Child）：某个节点的直接后继。
- 父节点（Parent）：某个节点的直接前驱。
- 叶子节点（Leaf）：没有子节点的节点。
下面用Python定义一个简单的树：
class TreeNode:
def __init__(self, value):
self.value = value # 节点值
self.children = [] # 子节点列表
# 创建树
root = TreeNode("A")
child1 = TreeNode("B")
child2 = TreeNode("C")
root.children.append(child1)
root.children.append(child2)
# 打印树结构
def print_tree(node, level=0):
print(" " * level + node.value) # 按层级打印
for child in node.children:
print_tree(child, level + 1)
print_tree(root)
运行结果：
A
B
C
是不是很简单？接下来我们还会深入讲解如何用算法处理这些结构！
二、使用Python实现深度优先搜索(DFS)算法
1. 什么是深度优先搜索(DFS)
深度优先搜索（DFS）是一种遍历图或树的常用算法。它从起始节点开始，沿着一条路径尽可能深入地探索，直到无法继续为止，然后回溯到上一个节点，重复这个过程。
举个例子：想象你在一个迷宫里，总是选择第一个路口一直走下去，直到走不通才返回之前的岔路口尝试另一条路。
2. Python代码实现DFS
我们可以用递归或者栈来实现DFS。下面是一个基于递归的简单实现：
# 定义图结构为字典形式
graph = {
'A': ['B', 'C'],
'B': ['A', 'D', 'E'],
'C': ['A', 'F'],
'D': ['B'],
'E': ['B', 'F'],
'F': ['C', 'E']
}
# 定义DFS函数
def dfs(graph, node, visited=None):
if visited is None: # 初始化访问列表
visited = set()
visited.add(node) # 标记当前节点为已访问
print(node, end=" ") # 打印节点
for neighbor in graph[node]: # 遍历相邻节点
if neighbor not in visited: # 如果相邻节点未访问，则递归调用
dfs(graph, neighbor, visited)
# 调用DFS函数
dfs(graph, 'A')
运行结果：
A B D E F C
这段代码展示了如何通过递归实现DFS，从节点'A'开始遍历整个图。每个节点只会被访问一次，避免了无限循环的问题。
三、使用Python实现广度优先搜索(BFS)算法
1. 什么是广度优先搜索（BFS）
广度优先搜索（BFS）是一种用于图或树的遍历算法，它从根节点开始，逐层访问所有邻居节点。比如，我们要找朋友的朋友列表，BFS就很适合！下面通过一个简单的例子来演示。
from collections import deque
# 定义图结构
graph = {
"你": ["Alice", "Bob", "Claire"],
"Alice": ["Peggy"],
"Bob": ["Anuj", "Peggy"],
"Claire": ["Thom", "Jonny"]
}
def bfs(name):
search_queue = deque() # 创建队列
search_queue += graph[name] # 将图中的邻居加入队列
searched = [] # 记录已检查过的人
while search_queue:
person = search_queue.popleft() # 取出第一个人
if person not in searched: # 如果这个人没被检查过
if person_is_seller(person): # 检查是否是销售员
print(f"{person} 是芒果销售商！")
return True
else:
search_queue += graph.get(person, []) # 不是销售商，将这个人的朋友加入队列
searched.append(person) # 标记为已检查
return False
def person_is_seller(name):
return name[-1] == 'm' # 假设名字以m结尾的是销售商
bfs("你") # 调用BFS函数
运行结果可能为：
Thom 是芒果销售商！
这段代码展示了如何用BFS查找芒果销售商。我们使用队列保存需要检查的人，并逐层扩展搜索范围，直到找到目标！
四、理解并实现Dijkstra最短路径算法
1. Dijkstra算法的基本原理
Dijkstra算法是用来解决单源最短路径问题的经典算法。它的核心思想是：从起点出发，逐步找到离起点最近的节点，并更新其他节点的距离。假设我们有一个图，每个边都有权重（表示距离），目标是从起点到所有其他节点的最短路径。
比如，想象一个城市地图，你想知道从家到公司的最短路线。Dijkstra算法就能帮你完成！
import heapq
def dijkstra(graph, start):
# 初始化距离字典，所有节点距离设为无穷大
distances = {node: float('inf') for node in graph}
distances[start] = 0 # 起点距离为0
priority_queue = [(0, start)] # 优先队列存储(距离, 节点)
while priority_queue:
current_distance, current_node = heapq.heappop(priority_queue)
# 如果当前距离大于记录的距离，则跳过
if current_distance > distances[current_node]:
continue
# 遍历邻居节点
for neighbor, weight in graph[current_node].items():
distance = current_distance + weight
# 如果找到更短路径，更新距离并加入队列
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(priority_queue, (distance, neighbor))
return distances
# 示例图结构
graph = {
'A': {'B': 1, 'C': 4},
'B': {'A': 1, 'C': 2, 'D': 5},
'C': {'A': 4, 'B': 2, 'D': 1},
'D': {'B': 5, 'C': 1}
}
print(dijkstra(graph, 'A')) # 输出: {'A': 0, 'B': 1, 'C': 3, 'D': 4}.
代码解析：
- graph 是一个字典，表示带权图。例如，'A': {'B': 1, 'C': 4} 表示从 A 到 B 的距离是 1，到 C 的距离是 4。
- 使用优先队列（heapq 模块）来确保每次处理的是当前最短路径的节点。
- 遍历邻居节点时，动态更新最短距离。
通过这段代码，你可以轻松计算任意节点间的最短路径！
五、使用Kruskal算法实现最小生成树
1. Kruskal算法简介
Kruskal算法是一种用来求解图的最小生成树的经典算法。它的核心思想是：按照边的权重从小到大排序，逐步选择不形成环路的边，直到所有顶点都被连接起来。比如，一个城市之间的道路网络，如何用最少的成本修建公路？这就是Kruskal算法能解决的问题！
# 示例代码：Kruskal算法实现
class UnionFind:
def __init__(self, n):
self.parent = list(range(n))
def find(self, x):
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
rootX = self.find(x)
rootY = self.find(y)
if rootX != rootY:
self.parent[rootX] = rootY
def kruskal(edges, n):
edges.sort(key=lambda x: x[2]) # 按权重排序
uf = UnionFind(n)
mst = []
for u, v, w in edges:
if uf.find(u) != uf.find(v): # 如果不形成环
uf.union(u, v)
mst.append((u, v, w))
return mst
# 测试数据
edges = [(0, 1, 7), (0, 3, 5), (1, 2, 8), (1, 3, 9), (2, 3, 6), (3, 4, 4)]
n = 5
result = kruskal(edges, n)
print("最小生成树的边为：", result)
输出结果：
最小生成树的边为： [(3, 4, 4), (0, 3, 5), (2, 3, 6), (0, 1, 7)]
这段代码通过Union-Find结构来检测环路，确保每次添加的边都不会导致图中出现环。最终输出的是一组边，它们构成了最小生成树！是不是很神奇？
六、实现Topological排序处理有向无环图(DAG)
1. Topological排序基础
Topological排序是一种对有向无环图（DAG）进行线性排序的方法，确保每个节点都在其所有依赖节点之后。比如，课程安排中，先修课必须在选修课之前完成。
from collections import defaultdict, deque
# 构建图
graph = defaultdict(list)
edges = [(0, 1), (0, 2), (1, 3), (2, 3)]
for u, v in edges:
graph[u].append(v)
# 计算入度
in_degree = {u: 0 for u in graph}
for u in graph:
for v in graph[u]:
in_degree[v] = in_degree.get(v, 0) + 1
# 拓扑排序
queue = deque([u for u in in_degree if in_degree[u] == 0])
result = []
while queue:
node = queue.popleft()
result.append(node)
for neighbor in graph[node]:
in_degree[neighbor] -= 1
if in_degree[neighbor] == 0:
queue.append(neighbor)
print(result) # 输出：[0, 1, 2, 3]
这段代码展示了如何通过BFS实现Topological排序。我们首先计算每个节点的入度，然后将入度为0的节点加入队列，依次处理并更新入度。最后得到的结果就是一种合法的拓扑顺序！
七、实战案例：社交网络中好友关系的分析与推荐系统构建
1. 社交网络中的图结构表示
在社交网络中，用户和好友关系可以用图结构来表示。每个用户是一个节点，好友关系是边。比如，小明和小红是好友，就可以用一条边连接他们。我们用Python字典来表示这个图：
graph = {
"小明": ["小红", "小刚"],
"小红": ["小明", "小丽"],
"小刚": ["小明"],
"小丽": ["小红"]
}
这段代码展示了如何用字典存储好友关系。
2. 使用DFS算法分析好友关系
深度优先搜索（DFS）可以用来查找两个用户之间是否存在好友关系路径。下面是一个简单的实现：
def dfs(graph, start, goal, visited=None):
if visited is None:
visited = set()
visited.add(start)
if start == goal:
return True
for neighbor in graph[start]:
if neighbor not in visited:
if dfs(graph, neighbor, goal, visited):
return True
return False
print(dfs(graph, "小明", "小丽")) # 输出: True
这段代码通过递归遍历图，判断“小明”和“小丽”是否有好友关系。
3. 使用BFS算法计算好友距离
广度优先搜索（BFS）可以帮助我们计算两个用户之间的最短好友关系距离。例如：
from collections import deque
def bfs(graph, start, goal):
queue = deque([(start, 0)])
visited = {start}
while queue:
node, dist = queue.popleft()
if node == goal:
return dist
for neighbor in graph[node]:
if neighbor not in visited:
visited.add(neighbor)
queue.append((neighbor, dist + 1))
return -1
print(bfs(graph, "小明", "小丽")) # 输出: 2
这里使用队列实现BFS，计算“小明”到“小丽”的好友距离为2。
4. 基于共同好友的推荐系统
我们可以根据用户的共同好友数量来推荐新朋友。比如：
def recommend_friends(graph, user):
friends = set(graph[user])
candidates = {}
for friend in friends:
for f_of_f in graph[friend]: # 遍历好友的好友
if f_of_f != user and f_of_f not in friends:
candidates[f_of_f] = candidates.get(f_of_f, 0) + 1
return sorted(candidates.items(), key=lambda x: x[1], reverse=True)
print(recommend_friends(graph, "小明")) # 输出: [('小丽', 1)]
这段代码根据共同好友的数量推荐新朋友给“小明”。
以上就是利用图结构和树形数据处理算法解决社交网络问题的简单示例！
