視覺化圖的基本演算法

0. About

關於圖的基本表示與基本演算法，包括圖的鄰接表和鄰接矩陣表示法；圖的廣度優先（BFS）與深度優先（DFS）搜尋演算法；最小權生成樹問題的 Kruskal 演算法與 Prim 演算法；單源最短路徑的 Dijkstra 演算法。

1. 鄰接表與鄰接矩陣表示

鄰接表表示法就是將圖的每個節點儲存在陣列中，每個節點指向與之相鄰的節點所組成的連結串列：

class GraphTable:  
    def __init__(self, nodes, edges, is_dir = False):
        self.nodes = nodes
        self.edges = edges
        self.is_dir = is_dir
        self.graph = []
        for node in nodes:
            self.graph.append([node])
        for edge in edges:
            for n in self.graph:
                if n[0] == edge[0]:
                    n.append(edge[1])
                if not is_dir:
                    if n[0] == edge[1]:
                        n.append(edge[0])
        self.G = None
    def __str__(self):
        return 'n'.join([str(n) for n in self.graph])
    def draw(self):
        settings = dict(name='Graph', engine='circo', node_attr=dict(shape='circle'), format='png')
        self.G = Digraph(**settings) if self.is_dir else Graph(**settings)
        for node in self.nodes:
            self.G.node(str(node), str(node))
        for edge in self.edges:
            self.G.edge(str(edge[0]), str(edge[1]))
        return self.G

1234567891011121314151617181920212223242526

classGraphTable:def __init__(self,nodes,edges,is_dir=False):self.nodes=nodesself.edges=edgesself.is_dir=is_dirself.graph=[]fornode innodes:self.graph.append([node])foredge inedges:forninself.graph:ifn[0]==edge[0]:n.append

(edge[1])ifnotis_dir:ifn[0]==edge[1]:n.append(edge[0])self.G=Nonedef __str__(self):return'n'.join([str(n)forninself.graph])def draw(self):settings=dict(name='Graph',engine='circo',node_attr=dict(shape='circle'),format='png')self.G=Digraph(**settings)ifself.is_dir elseGraph(**settings)fornode inself.nodes

:self.G.node(str(node),str(node))foredge inself.edges:self.G.edge(str(edge[0]),str(edge[1]))returnself.G

gt = GraphTable([1,2,3,4,5], [(1,2), (1,5), (2,5), (2,4), (5,4), (2,3), (3,4)])  
print(gt)  
gt.draw()  
"""
[1, 2, 5]
[2, 1, 5, 4, 3]
[3, 2, 4]
[4, 2, 5, 3]
[5, 1, 2, 4]
"""

12345678910

gt=GraphTable([1,2,3,4,5],[(1,2),(1,5),(2,5),(2,4),(5,4),(2,3),(3,4)])print(gt)gt.draw()"""[1, 2, 5][2, 1, 5, 4, 3][3, 2, 4][4, 2, 5, 3][5, 1, 2, 4]"""

鄰接表無向圖

dgt = GraphTable([1,2,3,4,5], [(1,2), (1,5), (2,5), (2,4), (5,4), (2,3), (3,4)], is_dir=True)  
print(dgt)  
dgt.draw()  
"""
[1, 2, 5]
[2, 5, 4, 3]
[3, 4]
[4]
[5, 4]
"""

12345678910

dgt=GraphTable([1,2,3,4,5],[(1,2),(1,5),(2,5),(2,4),(5,4),(2,3),(3,4)],is_dir=True)print(dgt)dgt.draw()"""[1, 2, 5][2, 5, 4, 3][3, 4][4][5, 4]"""

鄰接表有向圖

鄰接矩陣表示法則是用一個 N 階矩陣來表示，其中任意兩個節點所對應的矩陣中的值為0或1表示兩個節點是否相連通：

class GraphMatrix:  
    def __init__(self, nodes, edges, is_dir=False):
        self.nodes = nodes
        self.edges = edges
        self.graph = []
        for _ in range(len(nodes)):
            self.graph.append([0]*len(nodes))

        for (x, y) in edges:
            self.graph[x-1][y-1] = 1
            if not is_dir:
                self.graph[y-1][x-1] = 1
    def __str__(self):
        return str('n'.join([str(i) for i in self.graph]))

1234567891011121314

classGraphMatrix:def __init__(self,nodes,edges,is_dir=False):self.nodes=nodesself.edges=edgesself.graph=[]for_inrange(len(nodes)):self.graph.append([0]*len(nodes))for(x,y)inedges:self.graph[x-1][y-1]=1ifnotis_dir:self.graph[y-1][x-1]=1def __str__(self):returnstr('n'.join([str(i)foriinself.graph]))

gm = GraphMatrix([1,2,3,4,5], [(1,2), (1,5), (2,5), (2,4), (5,4), (2,3), (3,4)])  
print(gm)  
"""
[0, 1, 0, 0, 1]
[1, 0, 1, 1, 1]
[0, 1, 0, 1, 0]
[0, 1, 1, 0, 1]
[1, 1, 0, 1, 0]
"""

123456789

gm=GraphMatrix([1,2,3,4,5],[(1,2),(1,5),(2,5),(2,4),(5,4),(2,3),(3,4)])print(gm)"""[0, 1, 0, 0, 1][1, 0, 1, 1, 1][0, 1, 0, 1, 0][0, 1, 1, 0, 1][1, 1, 0, 1, 0]"""

dgm = GraphMatrix([1,2,3,4,5], [(1,2), (1,5), (2,5), (2,4), (5,4), (2,3), (3,4)], is_dir=True)  
print(dgm)  
"""
[0, 1, 0, 0, 1]
[0, 0, 1, 1, 1]
[0, 0, 0, 1, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 1, 0]
"""

123456789

dgm=GraphMatrix([1,2,3,4,5],[(1,2),(1,5),(2,5),(2,4),(5,4),(2,3),(3,4)],is_dir=True)print(dgm)"""[0, 1, 0, 0, 1][0, 0, 1, 1, 1][0, 0, 0, 1, 0][0, 0, 0, 0, 0][0, 0, 0, 1, 0]"""

這兩種表示方法都可以很容易地擴充套件為加權圖，對於比較稀疏的圖（定點數遠大於邊的數量）通常採用鄰接表表示法，後面涉及到的演算法均採用鄰接表表示法。

2. 廣度優先搜尋與深度優先搜尋

廣度優先搜尋就是按層遍歷樹時用到的思想，即先儘可能多地訪問直接相連的節點，再向深處延伸，因此需要使用佇列儲存訪問過的節點。

# 定義一個列舉型別，用於標記訪問過的節點的狀態
# WHITE 表示未檢視過
# GRAY 表示檢視過但未訪問
# BLACK 表示已經訪問過
import enum  
class Color(enum.Enum):  
    WHITE = 0
    GRAY  = 1
    BLACK = 2

123456789

# 定義一個列舉型別，用於標記訪問過的節點的狀態# WHITE 表示未檢視過# GRAY 表示檢視過但未訪問# BLACK 表示已經訪問過import enumclassColor(enum.Enum):WHITE=0GRAY=1BLACK=2

# 需要向 GraphTable 新增方法 adjs 用於
# 查詢所有與某節點直接相連的節點
def adjs(self, node):  
  return list(filter(lambda n: n[0] == node, self.graph))[0][1:]

def BFS(G, s):  
    color = {}
    dists = {}
    parent= {}
    for node in G.graph:
        color[node[0]] = Color.WHITE
        dists[node[0]] = -1
        parent[node[0]]= None
    color[s] = Color.GRAY
    dists[s] = 0
    queue = [s]
    while len(queue):
        cursor = queue.pop(0)
        for v in G.adjs(cursor):
            if color[v] == Color.WHITE:
                color[v] = Color.GRAY
                dists[v] = dists[cursor] + 1
                parent[v] = cursor
                queue.append(v)
        color[cursor] = Color.BLACK
        print("[{}] visited!".format(cursor))
    return parent

123456789101112131415161718192021222324252627

# 需要向 GraphTable 新增方法 adjs 用於# 查詢所有與某節點直接相連的節點def adjs(self,node):returnlist(filter(lambdan:n[0]==node,self.graph))[0][1:]def BFS(G,s):color={}dists={}parent={}fornode inG.graph:color[node[0]]=Color.WHITEdists[node[0]]=-1parent[node[0]]=Nonecolor[s]=Color.GRAYdists[s]=0queue=[s]whilelen(queue):cursor=queue.pop(0)forvinG.adjs(cursor):ifcolor[v]==Color.WHITE:color[v]=Color.GRAYdists[v]=dists[cursor]+1parent[v]=cursorqueue.append(v)color[cursor]=Color.BLACKprint("[{}] visited!".format(cursor))returnparent

返回的 parent 儲存了每個被訪問節點的上一個節點，可以通過遞迴找出訪問路徑：

def shortest_path(G, s, v, visit, search = BFS):  
    parent = search(G, s)
    print(parent)
    def visit_path(parent, s, v, visit):
        if v == s:
            visit(s)
        elif parent[v] is None:
            print("No path from {} to {}".format(s, v))
        else:
            visit_path(parent, s, parent[v], visit)
            visit(v)
    visit_path(parent, s, v, visit)
path = []  
shortest_path(gt, 1, 3, path.append)  
print(path)  
"""
[1] visited!
[2] visited!
[5] visited!
[4] visited!
[3] visited!
[1, 2, 3]
"""

1234567891011121314151617181920212223

視覺化圖的基本演算法

1. 鄰接表與鄰接矩陣表示

2. 廣度優先搜尋與深度優先搜尋

視覺化圖的基本演算法

Matplotlib資料視覺化——圖中圖

第十一週【專案1-圖基本演算法庫】

雙目視覺---影象匹配基本演算法總結

Python資料分析及視覺化的基本環境

視覺化歸併排序演算法

2015年大二上-資料結構-圖-1-(1)圖基本演算法庫

資料視覺化：基本圖表

第12周專案1 圖基本演算法庫

在ASP.NET Core中建立自定義端點視覺化圖

資料結構-基於鄰接矩陣實現圖的遍歷視覺化及使用Floyd、Dijkstra演算法求解最短路徑（JavaScript實現）

資料結構-基於鄰接表實現圖的遍歷視覺化及使用Floyd、Dijkstra演算法求解最短路徑（JavaScript實現）

一圖抵千言：帶你瞭解最直觀的神經網路架構視覺化

資料視覺化：淺談熱力圖如何在前端實現

圖——基本的圖演算法（四）關鍵路徑

圖——基本的圖演算法（三）拓撲排序

圖——基本的圖演算法（二）圖的遍歷

kafka視覺化客戶端工具（Kafka Tool）的基本使用

matplotlib學習——資料視覺化基本處理

tensorflow基本教程6：視覺化結果

視覺化圖的基本演算法

1. 鄰接表與鄰接矩陣表示

2. 廣度優先搜尋與深度優先搜尋

相關推薦