数据结构 图论DFS、BFS、最短路径树、最小生成树 python实现
广度优先遍历(BFS)
图的广度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后从v出发依次访问v的每个未被访问的邻接点w。当v的所有邻接点全部访问完后，再对v的每个邻接点w继续进行广度优先遍历，直至图中所有和源点v有路径相通的顶点均已被访问为止。若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点为新的源点重复上述过程，直至图中所有的顶点均已被访问为止。
如下代码只考虑无向连通图，即图中任意两个顶点均有路径相连。同时由于图的广度优先遍历不唯一，以下代码对于多邻点的顶点的遍历，按顶点值由低到高进行广度优先遍历。
代码运行后，第一行输入图的顶点总数目n，顶点依次编号为1，2…n，顶点编号即对应顶点值；第二行输入图的总边数m，接下来m行输入每条边的两个顶点，以逗号分隔；最后输入遍历的始发顶点编号x。比如：下图输入顶点数8（对应的顶点为1~8），边数10和边集，始发顶点为8，得到的广度优先遍历的结果为：8 1 2 5 3 6 4 7。 程序输出广度遍历结果（空格隔开）
class Graph(object):
def __init__(self,*args,**kwargs):
self.node_neighbors = {} # 定义顶点与邻接顶点集为字典结构
self.visited = {} # 定义已访问顶点集为字典结构
def add_nodes(self,nodelist):
for node in nodelist:
self.add_node(node)
def add_node(self,node):
if not node in self.nodes():
self.node_neighbors[node] = []
def add_edge(self,edge):
u,v = edge
if(v not in self.node_neighbors[u]) and ( u not in self.node_neighbors[v]): # 此处可添加自己指向自己的边
self.node_neighbors[u].append(v)
if(u!=v):
self.node_neighbors[v].append(u)
def nodes(self):
return self.node_neighbors.keys()
def breadth_first_search(self,root=None): # 广度优先需用到队列结构
queue = []
order = []
def bfs():
while len(queue)> 0:
node = queue.pop(0)
self.visited[node] = True
self.node_neighbors[node].sort()
for n in self.node_neighbors[node]:
if (not n in self.visited) and (not n in queue):
queue.append(n)
order.append(n)
if root:
queue.append(root)
order.append(root)
bfs()
for node in self.nodes():
if not node in self.visited:
queue.append(node)
order.append(node)
bfs()
# print(order)
return order
if __name__ == '__main__':
g = Graph()
node_num=int(input())#顶点的数目
g.add_nodes([i+1 for i in range(node_num)])
vec_num=int(input())#边的数目
for i in range(vec_num):
g.add_edge(tuple(int(n) for n in input().split(',')))
order = g.breadth_first_search(int(input()))
# print(order)
for i in order:
print(i, end=' ')
测试结果：
深度优先遍历（DFS）
图的深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点均已被访问为止。若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点为新的源点重复上述过程，直至图中所有的顶点均已被访问为止。请编写程序实现图的深度优先遍历，从节点1开始。同时由于图的深度优先遍历不唯一，我们约定对于多邻点的顶点的遍历，按顶点值由低到高进行深度优先遍历。
第一行输入图的顶点的数目；第二行输入图的边数；接下来逐行输入边。
比如：下图（还是上面那个图）输入顶点数8（对应的顶点为1~8），边数10和边集，得到的深度优先遍历的结果为：1 3 7 5 4 6 8 2
class Graph(object):
def __init__(self,*args,**kwargs):
self.node_neighbors = {}
self.visited = {}
def add_nodes(self,nodelist):
for node in nodelist:
self.add_node(node)
def add_node(self,node):
if not node in self.nodes():
self.node_neighbors[node] = []
def add_edge(self,edge):
u,v = edge
if(v not in self.node_neighbors[u]) and ( u not in self.node_neighbors[v]):
self.node_neighbors[u].append(v)
if(u!=v):
self.node_neighbors[v].append(u)
def nodes(self):
return self.node_neighbors.keys()
def depth_first_search(self,root=None):
order = []
def dfs(node):
self.visited[node] = True
order.append(node)
self.node_neighbors[node].sort()
for n in self.node_neighbors[node]:
if not n in self.visited:
dfs(n)
if root:
dfs(root)
for node in self.nodes():
if not node in self.visited:
dfs(node)
#print(order)
return order
if __name__ == '__main__':
g = Graph()
node_num=int(input())#顶点的数目
#node_c=input().split(',')
#g.add_nodes(i for i in node_c)
g.add_nodes([i+1 for i in range(node_num)])
vec_num=int(input())#边的数目
for i in range(vec_num):
g.add_edge(tuple(int(n) for n in input().split(',')))
#print("nodes:", g.nodes())
order = g.depth_first_search(1)
for i in order:
print(i,end=' ')
最短路径树
计算最短路径树使用邻接矩阵表示较方便。它是指到某个节点路径都是最短的一棵树。下面的代码求所有节点到图的第一个节点构成的最短路径树。最短路径树使用邻接矩阵表示法较方便。第一行是图的节点数n，第二行到第n+1行，是对应的图的邻接矩阵。然后，在一行中输出从所有节点（包含第一个节点自己）到第一个节点的最短路径的长度。
n=int(input())
path_cost=[]
for i in range(n):
path_cost.append(list(map(int,input().split())))
a=[0]+[200000000 for x in range(n-1)]
visit=[False]*n
for i in range(n):
min1=200000000
for j in range(n):
if (not visit[j]) and (a[j]<min1):
min1=a[j]
k=j
visit[k]=True
for j in range(n):
if(not visit[j]) and (a[k]+path_cost[k][j]<a[j]):
a[j]=a[k]+path_cost[k][j]
print(a)
如果两个节点之间不存在边，权重就取一个很大值，姑且输入65535。
最小生成树
一个有n个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有n个结点，并且有保持图连通的最少的边。
而最小生成树便是指该生成树所有边的权值之和是最小的生成树。常用的方法有prim算法和kruskal算法。
这个代码输入第一行为正整数N。（N>0）N为图的节点数，接下来输入一个N行N列的矩阵C，因为是无向图，所以这是一个沿对角线对称的矩阵，矩阵的元素Cij代表从i节点到j节点的花费值。若该条边不存在，则设置数值为65535；输出最小生成树的cost。这里给出了两种算法的函数。
class Graph(object):
def __init__(self, maps):
self.maps = maps
self.nodenum = self.get_nodenum()
self.edgenum = self.get_edgenum()
def get_nodenum(self):
return len(self.maps)
def get_edgenum(self):
count = 0
for i in range(self.nodenum):
for j in range(i):
if self.maps[i][j] > 0 and self.maps[i][j] < 9999:
count += 1
return count
def kruskal(self):
res = []
sum_cost=0
if self.nodenum <= 0 or self.edgenum < self.nodenum-1:
return res
edge_list = []
for i in range(self.nodenum):
for j in range(i,self.nodenum):
if self.maps[i][j] < 9999:
edge_list.append([i, j, self.maps[i][j]])#按[begin, end, weight]形式加入
edge_list.sort(key=lambda a:a[2])#已经排好序的边集合
group = [[i] for i in range(self.nodenum)]
for edge in edge_list:
for i in range(len(group)):
if edge[0] in group[i]:
m = i
if edge[1] in group[i]:
n = i
if m != n:
res.append(edge)
sum_cost +=edge[2]
group[m] = group[m] + group[n]
group[n] = []
#return res
return sum_cost
def prim(self):
sum_cost=0
res = []
if self.nodenum <= 0 or self.edgenum < self.nodenum-1:
return res
res = []
seleted_node = [0]
candidate_node = [i for i in range(1, self.nodenum)]
while len(candidate_node) > 0:
begin, end, minweight= 0, 0, 9999
for i in seleted_node:
for j in candidate_node:
if self.maps[i][j] < minweight:
minweight = self.maps[i][j]
begin = i
end = j
res.append([begin, end, minweight])
sum_cost += minweight
seleted_node.append(end)
candidate_node.remove(end)
return sum_cost
max_value = 65535
'''
row0 = [0,7,max_value,max_value,max_value,5]
row1 = [7,0,9,max_value,3,max_value]
row2 = [max_value,9,0,6,max_value,max_value]
row3 = [max_value,max_value,6,0,8,10]
row4 = [max_value,3,max_value,8,0,4]
row5 = [5,max_value,max_value,10,4,0]
maps = [row0, row1, row2,row3, row4, row5]
maps2=[[0,6,3,2,99,99,99],
[6,0,5,99,99,2,99],
[3,5,0,3,99,1,99],
[2,99,3,0,5,99,6],
[99,99,99,5,0,6,2],
[99,2,1,99,6,0,4],
[99,99,99,6,2,4,0]]
'''
n_length=int(input())
maps=[]
for i in range(n_length):
maps.append(list(map(int,input().split())))
graph = Graph(maps)
#print('邻接矩阵为\n%s'%graph.maps)
#print('节点数据为%d，边数为%d\n'%(graph.nodenum, graph.edgenum))
#print('最小生成树kruskal算法')
#print(graph.kruskal())
#print('最小生成树prim算法')
print(graph.prim())
