全网最全Python图算法

最新推荐文章于 2023-04-19 13:51:47 发布

龙晨天

最新推荐文章于 2023-04-19 13:51:47 发布

阅读量4k

点赞数 13

分类专栏：算法学习文章标签：算法 python 图论

本文链接：https://blog.csdn.net/qq_30759585/article/details/126454566

版权

算法学习专栏收录该内容

11 篇文章 3 订阅

订阅专栏

全网最全Python图算法

图几个关键概念

⚫图可以表示为一个二元组𝑮 =< 𝑽, 𝑬 >，其中

𝑽表示非空顶点集，其元素称为顶点(Vertex)
𝑬表示边集，其元素称为边(Edge)
𝒆 = 𝒖, 𝒗 表示一条边，其中𝒖 ∈ 𝑽, 𝒗 ∈ 𝑽, 𝒆 ∈ 𝑬

⚫无向图

若顶点𝒖到𝒗之间的边没有方向，则称这条边为无向边（Edge），用无序偶对（𝒖,𝒗）来表示。
如果图中任意两个顶点之间的边都是无向边，则称该图为无向图。

⚫有向图

若顶点𝒖到𝒗之间的边有方向，则称这条边为有向边，也称为弧（Arc）。用有序偶<𝒖,𝒗>来表示，𝒖称为弧尾（Tail），𝒗称为弧头（Head）。
如果图中任意两个顶点之间的边都是有向边，则称该图为有向图（Directed graphs）。
⚫ 有向图顶点的度分为入度和出度
- 顶点𝒖的入度：起点为𝒖的边数
- 顶点𝒖的出度：终点为𝒖的边数

⚫ 相邻(Adjacent)

边𝒖, 𝒗 连接的顶点𝒖和𝒗相邻

⚫ 关联(Incident)

边𝒖, 𝒗 和其连接的顶点𝒖(或𝒗)相互关联

⚫ 顶点的度(Degree of a Vertex)

顶点𝒗的度𝒅𝒆𝒈(𝒗)是𝒗关联的边数

⚫ 图的度(Degree of a Graph)

图𝑮 =< 𝑽, 𝑬 >的度，是图各顶点的度之和，𝒅𝒆𝒈(𝑮) = σ𝒗∈𝑽 𝒅𝒆𝒈(𝒗)

⚫握手定理(Handshaking Lemma)

无向图的度是边数的两倍， 𝒅𝒆𝒈(𝑮) = 𝟐|𝑬|

⚫ 路径(Path)

图中一个的顶点序列< 𝒗𝟎, 𝒗𝟏, … , 𝒗𝒌 >称为𝒗𝟎到𝒗𝒌的路径
路径包含顶点𝒗𝟎, 𝒗𝟏, … , 𝒗𝒌和边𝒗𝟎, 𝒗𝟏 , 𝒗𝟏, 𝒗𝟐 , … , (𝒗𝒌−𝟏, 𝒗𝒌)
存在路径< 𝒗𝟎, 𝒗𝟏, … , 𝒗𝒌 > ，则𝒗𝟎可达𝒗𝒌
如果𝒗𝟎, 𝒗𝟏, … , 𝒗𝒌互不相同，则该路径是简单的

⚫环路(Cycle)

如果路径< 𝒗𝟎, 𝒗𝟏, … , 𝒗𝒌 >中𝒗𝟎 = 𝒗𝒌且至少包含一条边，则该路径构成环路
如果𝒗𝟏, 𝒗𝟐, … , 𝒗𝒌互不相同，则该环路是简单的

⚫连通(Connectivity)

如果图的任意对顶点互相可达，则称该图是连通的，反之称为非连通。

⚫ 通分量(Connected Components)

根据是否连通将顶点进行分组，相互可达的顶点集称为连通分量

⚫ 子图(Subgraph)

如果𝑽′ ⊆ 𝑽, 𝑬′ ⊆ 𝐄，则称图𝑮’ =< 𝑽’, 𝑬’ >是图𝑮的一个子图

⚫ 生成子图(Spanning Subgraph)

如果𝑽′ = 𝑽, 𝑬′ ⊆ 𝐄，则称图𝑮’ =< 𝑽’, 𝑬’ >是图𝑮的一个生成子图

⚫ 树(Tree)

连通、无环图𝑻 =< 𝑽𝑻, 𝑬𝑻 >，树有|𝑽𝑻| − 𝟏条边

⚫ 森林(Forest)

一至多棵树组成的无环图

图的存储形式(边、顶点的数据结构)

⚫ 图𝑮 =< 𝑽, 𝑬 > ，其邻接链表由|𝑽|条链表的数组构成

每个顶点有一条链表，包含所有与其相邻的顶点
𝑨𝒅𝒋[𝒂] ={𝒃, 𝒅}; 𝑨𝒅𝒋[𝒃] ={ 𝒂, 𝒄, 𝒅, 𝒇 }; 𝑨𝒅𝒋[𝒄] ={𝒃, 𝒇 }; …
空间大小𝑶(|𝑽| + |𝑬|)

为了实现稀疏连接的图，更高效的方式是使用邻接表。在邻接表实现中，我们为图对象的所有顶点保存一个主列表，同时为每一个顶点对象都维护一个列表，其中记录了与它相连的顶点。在对Vertex类的实现中，我们使用字典（而不是列表），字典的键是顶点，值是权重。

邻接表的优点是能够紧凑地表示稀疏图。此外，邻接表也有助于方便地找到与某一个顶点相连的其他所有顶点。

在Python中，通过字典可以轻松地实现邻接表。我们要创建两个类：Graph类存储包含所有顶点的主列表，Vertex类表示图中的每一个顶点。

Vertex使用字典connectedTo来记录与其相连的顶点，以及每一条边的权重。
以下Vertex类的实现，其构造方法简单地初始化id（它通常是一个字符串），以及字典connectedTo,以及其他算法所需要的辅助参数。

addNeighbor方法添加从一个顶点到另一个的连接。
getConnections方法返回邻接表中的所有顶点，由connectedTo来表示。
getWeight方法返回从当前顶点到以参数传入的顶点之间的边的权重。
setPred()\getPred() 设置\获取前驱顶点。
setColor()\getColor() 设置\获取顶点状态（颜色）。
setDistance()\getDistance() 设置\获取顶点的距离。

class Vertex:
    '''
    创建一个空顶点
    '''
    def __init__(self,key):
        self.id = key
        self.connectedTo = {}
        self.color = 'white'
        self.dist = inf
        self.pred = None
        self.disc = 0
        self.fin = 0
    def addNeighbor(self, nbr, weight = 0):
        '''
        添加邻接的顶点
        :param nbr: 邻接的顶点
        :param weight: 默认为0
        :return:
        '''
        self.connectedTo[nbr] = weight

    def getConnections(self):
        '''
        获取邻接的所以顶点
        :return:
        '''
        return self.connectedTo.keys()
    def getId(self):
        '''
        获取自身顶点的值
        :return:
        '''
        return self.id
    def getWeight(self, nbr):
        '''
        两顶点连接边的权重
        :param nbr:
        :return:
        '''
        return self.connectedTo[nbr]

    def setColor(self, color):
        '''
        设置顶点的颜色（一般设置为白色表示未访问，灰色表示待处理，黑色表示访问完成）。
        :param color: 字符串、或者int 例如 color = 'white' color = -1
        :return:
        '''
        self.color = color

    def getColor(self):
        '''
        获取顶点的颜色，（一般设置为白色表示未访问，灰色表示待处理，黑色表示访问完成）
        :return:
        '''
        return self.color

    def setDistance(self, d):
        '''
        设置顶点距离，（不同算法有不同的意义）如单源最短路径表示源点到该点最短距离，最小生成树表示离该顶点最小的权重。
        :param d:
        :return:
        '''
        self.dist = d
        
    def getDistance(self):
        '''
        获取该顶点的距离，（不同算法有不同的意义）如单源最短路径表示源点到该点最短距离，最小生成树表示离该顶点最小的权重。
        :return:
        '''
        return self.dist


    def setPred(self, p):
        '''
        设置该顶点的前驱顶点
        :param p:
        :return:
        '''
        self.pred = p

    def getPred(self):
        '''
        设置该顶点的前驱顶点
        :return:
        '''
        return self.pred

    ##以下方法用得不多，帮助理解。

    def setDiscovery(self, dtime):
        '''
        设置顶点发现时间。
        :param dtime:
        :return:
        '''
        self.disc = dtime
    def getDiscovery(self):
        '''
        获取顶点发现时间。
        :return:
        '''
        return self.disc

    def setFinish(self, ftime):
        '''
        设置顶点完成时间。
        :param ftime:
        :return:
        '''
        self.fin = ftime

    def getFinish(self):
        '''
        获取顶点完成时间。
        :return:
        '''
        return self.fin

图的抽象数据类型

图的抽象数据类型由下列方法定义。

Graph()新建一个空图。
addVertex(vert)向图中添加一个顶点实例。
addEdge(fromVert, toVert)向图中添加一条有向边，用于连接顶点fromVert和toVert。
addEdge(fromVert, toVert, weight)向图中添加一条带权重weight的有向边，用于连接顶点fromVert和toVert。
getVertex(vertKey)在图中找到名为vertKey的顶点。
getVertices()以列表形式返回图中所有顶点。
in通过vertex in graph这样的语句，在顶点存在时返回True，否则返回False。
reverse()生成逆向图。
InDegreeUpdate 入度更新。
OutDegreeUpdate 出度更新。
bfs() 对图进行广度优先搜索。
dfs() 对图进行深度优先搜索。
prim() 生成最小生成树。
kruskal() 生成最小生成树。
dijkstra() 单源最短路径。
bellman_ford() 单源最短路径。
dfs_judge_cycle() 深度优先搜索进行环路判断。
topological_sort_bfs() 宽度优先搜索生成拓扑排序。
topological_sort_dfs() 深度优先搜索生成拓扑排序。
Strongly_Connected_Component()生成强联通分量。


class Graph:
    '''
    新建一个空图。
    '''
    def __init__(self):
        '''
        初始化邻接表，顶点个数
        '''
        self.vertList = {}
        self.numVertices = 0
        self.time = 0
    def addVertex(self, key):
        '''
        向图中添加一个顶点实例
        :param key:
        :return: None
        '''
        self.numVertices = self.numVertices + 1
        newVertex = Vertex(key)
        self.vertList[key] = newVertex
        return newVertex

    def getVertex(self, n):
        '''
        在图中找到名为n的顶点
        :param n:
        :return:
        '''
        if n in self.vertList:
            return self.vertList[n]
        else:
            return None
    def __contains__(self,n):
        '''
        对in进行重载
        :param n:
        :return:
        '''
        return n in self.vertList
    def addEdge(self, f, t, weight = 0):
        '''
        )向图中添加一条带权重cost的有向边，用于连接顶点f和t
        :param f:
        :param t:
        :param weight:
        :return: None
        '''
        if f not in self.vertList:
            nv = self.addVertex(f)
        if t not in self.vertList:
            nv = self.addVertex(t)
        self.vertList[f].addNeighbor(self.vertList[t],weight)

    def getVertics(self):
        '''
        以列表形式返回图中所有顶点
        :return: {}.keys()
        '''
        return self.vertList.keys()
    def __iter__(self):
        '''
        对迭代进行重载，方便遍历顶点邻接表
        :return:
        '''
        return iter(self.vertList.values())

图的遍历

广度优先搜索

广度优先搜索伪代码
在这里插入图片描述

在这里插入图片描述

    def bfs(self,start = None):
        '''
        广度优先搜索
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]
        start.setDistance(0)
        start.setPred(None)
        vertQueue = queue.Queue()
        vertQueue.put(start)
        out = []
        while vertQueue.empty() == False:
            currentVert = vertQueue.get()
            for nbr in currentVert.getConnections():
                if nbr.getColor() == 'white':
                    nbr.setColor('gray')
                    nbr.setDistance(currentVert.getDistance() + 1)
                    nbr.setPred(currentVert.getId())
                    vertQueue.put(nbr)
            currentVert.setColor('black')
            out.append(currentVert.id)

深度优先搜索

深度优先搜索伪代码
DFS(𝑮)
在这里插入图片描述

DFS-Visit(𝑮, 𝒗)
在这里插入图片描述

DFS(𝑮)

  def dfs(self):
        '''
        深度优先搜索
        :return:
        '''
        out = []
        self.time = 0
        for aVertex in self:
            aVertex.setColor('white')
            aVertex.setPred(None)
        for aVertex in self:
            if aVertex.getColor() == 'white':
                self.dfsvisit(aVertex,out)
        return out

    def dfsvisit(self, startVertex,out):
        startVertex.setColor('gray')
        self.time += 1
        startVertex.setDiscovery(self.time)
        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'white':
                nextVertex.setPred(startVertex.getId())
                self.dfsvisit(nextVertex,out)
        startVertex.setColor('black')
        self.time += 1
        startVertex.setFinish(self.time)
        out.append(startVertex.getId())

测试

在这里插入图片描述

if __name__ =='__main__':

    g = Graph()
    for i in range(1,9):
        g.addVertex(i)
    g.addEdge(1,2)
    g.addEdge(2,1)
    g.addEdge(1,5)
    g.addEdge(5,1)
    g.addEdge(2, 6)
    g.addEdge(6,2)
    g.addEdge(6, 3)
    g.addEdge(3,6)
    g.addEdge(6, 7)
    g.addEdge(7,6)
    g.addEdge(3, 7)
    g.addEdge(7,3)
    g.addEdge(3, 4)
    g.addEdge(4,3)
    g.addEdge(4, 8)
    g.addEdge(4,7)
    g.addEdge(7,4)
    g.addEdge(8,4)
    g.addEdge(7, 8)
    g.addEdge(8,7)


    g.bfs(g.vertList[2])
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()

    x = g.dfs()
    print(x)
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()
    for v in g:
        print(v.getDiscovery(),end = ' ')
    print()
    for v in g:
        print(v.getFinish(),end = ' ')
    print()
    #输出
    # 2 None 6 3 1 2 6 7 
    # 1 0 2 3 2 1 2 3

    # [8, 4, 7, 3, 6, 2, 5, 1]

    # None 1 6 7 1 2 3 4 
    # 1 0 2 3 2 1 2 3 
    # 1 2 4 6 14 3 5 7 
    # 16 13 11 9 15 12 10 8

最小生成树

prim最小生成树

prim最小生成树伪代码

在这里插入图片描述

    def prim_simple(self,start = None):
        '''
        prim最小生成树简单版本
        :param start: 迭代起点
        :return:
        '''
        #在有向图中，有可能存在这样一种情况：两个节点之间来和回的权重不一样
        #所以prim在某些情况下会失效
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)

        for i in range(self.numVertices):
            minDist = inf
            rec = -1
            for j in self:
                if j.getColor() == 'white' and j.getDistance() < minDist:
                    minDist = j.getDistance()
                    rec = j
                    
            for u in rec.getConnections():
                if rec.getWeight(u) < u.getDistance():
                    u.setDistance(rec.getWeight(u))
                    u.setPred(rec.getId())
                    
            rec.setColor('black')

            # for u in rec.getConnections():
            #     newCost = rec.getWeight(u) + rec.getDistance()
            #     if newCost < u.getDistance():
            #         u.setDistance(newCost)
            #         u.setPred(rec.getId())
            # rec.setColor('black')

prim 最小生成树（优先对列）

在这里插入图片描述

    def prim(self,start = None):
        '''
        prim最小生成树（采用优先队列）
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)
        pq = queue.PriorityQueue()

        for v in list(self.getVertics()):

            pq.put((self.vertList[v].getDistance(),v))


        while not pq.empty():
            (t, currentVert) = pq.get()
            currentVert = self.vertList[currentVert]
            for nextVert in currentVert.getConnections():
                newCost = currentVert.getWeight(nextVert)
                if newCost < nextVert.getDistance() and nextVert.getColor() == 'white':
                    nextVert.setPred(currentVert.getId())
                    nextVert.setDistance(newCost)
                    pq.put((newCost, nextVert.id))
            currentVert.setColor('black')

kruskal最小生成树

在这里插入图片描述


class DisjointSet:

    def __init__(self, element=None):
        self._father = {}
        self._rank = {}
        # 初始化时每个元素单独成为一个集合
        if element is not None:
            for i in element:
                self.add(i)

    def add(self, x):
        # 添加新集合
        # 如果已经存在则跳过
        if x in self._father:
            return
        self._father[x] = x
        self._rank[x] = 0

    def _query(self, x):
        # 如果father[x] == x，说明x是树根
        if self._father[x] == x:
            return x
        self._father[x] = self._query(self._father[x])
        return self._father[x]

    def merge(self, x, y):
        if x not in self._father:
            self.add(x)
        if y not in self._father:
            self.add(y)
        # 查找到两个元素的树根
        x = self._query(x)
        y = self._query(y)
        # 如果相等，说明属于同一个集合
        if x == y:
            return
        # 否则将树深小的合并到树根大的上
        if self._rank[x] < self._rank[y]:
            self._father[x] = y
        else:
            self._father[y] = x
            # 如果树深相等，合并之后树深+1
            if self._rank[x] == self._rank[y]:
                self._rank[x] += 1

    # 判断是否属于同一个集合
    def same(self, x, y):
        return self._query(x) == self._query(y)

在这里插入图片描述

    def kruskal(self):
        '''
        kruskal算法使用并查集类
        :return:
        '''
        disjoinset = DisjointSet([key.getId() for key in self])
        edges = []
        for v in self:
            for u in v.getConnections():
                edges.append((v.getId(),u.getId(),v.getWeight(u)))

        edges.sort(key = lambda a:a[2])

        minu_tree = []
        for edge in edges:
            u, v, w = edge
            if disjoinset.same(u, v):
                continue
            disjoinset.merge(u, v)
            self.getVertex(v).setPred(u)
            minu_tree.append(edge)
        for edge in minu_tree:
            self.getVertex(u)

        return minu_tree

测试

在这里插入图片描述

if __name__ =='__main__':

    g = Graph()
    g.addVertex('a')
    g.addVertex('b')
    g.addVertex('c')
    g.addVertex('d')
    g.addVertex('f')
    g.addVertex('h')
    g.addVertex('g')
    g.addVertex('i')
    g.addVertex('z')
    g.addEdge('a','b',4)
    g.addEdge('b','a',4)
    g.addEdge('a','h',8)
    g.addEdge('h','a',8)
    g.addEdge('b','c',8)
    g.addEdge('c','b',8)
    g.addEdge('b','h',1)
    g.addEdge('h','b',1)
    g.addEdge('h','i',7)
    g.addEdge('i','h',7)
    g.addEdge('c','i',2)
    g.addEdge('i','c',2)
    g.addEdge('c','d',7)
    g.addEdge('d','c',7)
    g.addEdge('i','g',4)
    g.addEdge('g','i',4)
    g.addEdge('g','f',2)
    g.addEdge('f','g',2)
    g.addEdge('f','z',10)
    g.addEdge('z','f',10)
    g.addEdge('d','f',14)
    g.addEdge('f','d',14)
    g.addEdge('d','z',9)
    g.addEdge('z','d',9)
    g.addEdge('c','f',6)
    g.addEdge('f','c',6)
    g.addEdge('h','g',1)
    g.addEdge('g','h',1)
    g.prim()
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()

    g.prim_simple()
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()
    x = g.kruskal()
    print(x)
    #输出
    # None a i c g b h g d 
    # 0 4 2 7 2 1 1 4 9 

    # a,0
    # b,4
    # h,1
    # g,1
    # f,2
    # i,4
    # c,2
    # d,7
    # z,9

    # None h i c g b h c d 
    # 0 1 2 7 2 1 1 2 9

    #（这个输出在遍历时被覆盖掉了，只能通过print打印查找记录） 
    # [('b', 'h', 1), ('h', 'g', 1), ('c', 'i', 2), ('f', 'g', 2), ('a', 'b', 4), ('g', 'i', 4), ('c', 'd', 7), ('d', 'z', 9)]

单源最短路径

dijkstra单源最短路径

在这里插入图片描述

    def dijkstra_simple(self,start = None):
        '''
         dijkstra单源最短路径简单版本
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)

        for i in range(self.numVertices):
            minDist = inf
            rec = 0
            for j in self:
                if j.getColor() == 'white' and j.getDistance() < minDist:
                    minDist = j.getDistance()
                    rec = j
            for u in rec.getConnections():
                if rec.getDistance() + rec.getWeight(u) < u.getDistance():
                    u.setDistance(rec.getDistance() + rec.getWeight(u))
                    u.setPred(rec.getId())
            rec.setColor('black')

dijkstra单源最短路径(优先队列)

在这里插入图片描述


    def dijkstra(self,start = None):
        '''
        dijkstra单源最短路径（使用优先队列）
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]


        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')

        start.setDistance(0)
        pq = queue.PriorityQueue()
        for v in list(self.getVertics()):
            pq.put((self.vertList[v].getDistance(),v))

        while not pq.empty():
            (t, currentVert) = pq.get()
            currentVert = self.vertList[currentVert]
            for nextVert in currentVert.getConnections():
                newDist = currentVert.getWeight(nextVert) + currentVert.getDistance()
                if newDist < nextVert.getDistance() and nextVert.getColor() == 'white':
                    nextVert.setPred(currentVert.getId())
                    nextVert.setDistance(newDist)
                    pq.put((newDist, nextVert.id))

            currentVert.setColor('black')

测试

在这里插入图片描述

if __name__ =='__main__':

    g = Graph()
    g.addVertex('s')
    g.addVertex('t')
    g.addVertex('x')
    g.addVertex('y')
    g.addVertex('z')
    g.addEdge('s','t',8)
    g.addEdge('s','y',5)
    g.addEdge('t','x',1)
    g.addEdge('t','y',2)
    g.addEdge('x','z',4)
    g.addEdge('y','t',3)
    g.addEdge('y','z',2)
    g.addEdge('y','x',9)
    g.addEdge('z','x',6)
    g.dijkstra()
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()

    g.dijkstra_simple()
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()

bellman_ford单源最短路径

在这里插入图片描述

   def bellman_ford(self,start = None):
        '''
        bellman_ford算法
        :param start:
        :return:
        '''
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        #可以用这种方法遍历 不过比较繁琐。
        # for v in self.getVertics():
        #     self.vertList[v].setDistance(inf)
        #     self.vertList[v].setPred(None)
        #     pred[v] = None
        for v in self:
            v.setDistance(inf)
            v.setPred(None)


        start.setDistance(0)
        for i in range(self.numVertices-1):
            for v in self:
                for u in v.getConnections():
                    if v.getDistance() + v.getWeight(u) < u.getDistance():
                        u.setDistance(v.getDistance() + v.getWeight(u))
                        u.setPred(v.getId())


        for v in self:
            for u in v.getConnections():
                if v.getDistance() + v.getWeight(u) < u.getDistance():
                    print("存在负环")
                    return False
        return True

测试

在这里插入图片描述


if __name__ =='__main__':

    bellman = Graph()
    bellman.addVertex('s')
    bellman.addVertex('t')
    bellman.addVertex('x')
    bellman.addVertex('y')
    bellman.addVertex('z')
    bellman.addEdge('s','t',6)
    bellman.addEdge('s','y',7)
    bellman.addEdge('t','x',5)
    bellman.addEdge('x','t',-2)
    bellman.addEdge('t','z',-4)
    bellman.addEdge('t','y',8)
    bellman.addEdge('y','z',2)
    bellman.addEdge('y','x',-3)
    bellman.addEdge('x','z',7)
    bellman.bellman_ford()
    for v in bellman:
        print(v)
    for v in bellman:
        print(v.getPred(),end = ' ')
    print()
    for v in bellman:
        print(v.getDistance(),end = ' ')
    print()
    #输出
    # None x y s t 
    # 0 2 4 7 -2

图的遍历的应用

有向图的环路存在性判断

在这里插入图片描述


    def dfs_judge_cycle(self):

        for aVertex in self:
            aVertex.setColor('white')
            aVertex.setPred(-1)
        for aVertex in self:
            if aVertex.getColor() == 'white':
                if self.dfs_visit_judge_cycle(aVertex) == True:
                    return True
        return False

    def dfs_visit_judge_cycle(self, startVertex):
        startVertex.setColor('gray')
        startVertex.setDiscovery(self.time)
        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'gray':
                return True
            if nextVertex.getColor() == 'white':
                nextVertex.setPred(startVertex.getId())
                if self.dfs_visit_judge_cycle(nextVertex) == True:
                    return True

            startVertex.setColor('black')

拓扑排序

广度优先策略

在这里插入图片描述

    #入度出度计算方法
    def getOutDegrees(self,vertex):
        '''
        获取某个顶点出度
        :param vertex:
        :return:
        '''

        return self.vertList[vertex].OutDegree

    def getInDegrees(self,vertex):
        '''
        获取某个顶点的入度（很蠢的一个做法哈哈）
        :param vertex:
        :return:
        '''
        #初始化完后遍历查找
        self.vertList[vertex].InDegree = 0
        for u in self:
            if self.vertList[vertex] in u.getConnections():
                self.vertList[vertex].InDegree += 1

        return self.vertList[vertex].InDegree
    def OutDegreeUpdate(self):
        for u in self:
            self.OutDegreeList[u.getId()] = len(u.getConnections())
    def InDegreeUpdate(self):
        for u in self:
            self.InDegreeList[u.getId()] = 0

        for u in self:
            for v in u.getConnections():
                self.InDegreeList[v.getId()] += 1

    def topological_sort_bfs(self):

        self.InDegreeUpdate()
        vertQueue = queue.Queue()
        out = []

        for v in self:
            if self.InDegreeList[v.getId()] == 0:
                vertQueue.put(v)

        while vertQueue.empty() == False:
            currentVert = vertQueue.get()
            # print(currentVert.getId(),end=" ")
            out.append(currentVert.getId())
            for nbr in currentVert.getConnections():
                self.InDegreeList[nbr.getId()] = self.InDegreeList[nbr.getId()] - 1
                if self.InDegreeList[nbr.getId()] == 0:
                    vertQueue.put(nbr)
        # print()
        # print(out)
        return out

深度优先策略

在这里插入图片描述

    def topological_sort_dfs(self):

        self.out = []
        L = []
        for aVertex in self:
            aVertex.setColor('white')
        for aVertex in self:
            if aVertex.getColor() == 'white':
                self.topological_sort_dfs_visit(aVertex, L)
        L.reverse()
        return L

    def topological_sort_dfs_visit(self, startVertex, L):

        startVertex.setColor('gray')

        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'white':
                self.topological_sort_dfs_visit(nextVertex, L)
        startVertex.setColor('black')
        L.append(startVertex.getId())

测试

在这里插入图片描述

if __name__ == '__main__':

    #拓扑排序测试
    topological = Graph()
    topological.addVertex('短裤')
    topological.addVertex('长裤')
    topological.addVertex('腰带')
    topological.addVertex('衬衫')
    topological.addVertex('领带')
    topological.addVertex('外套')
    topological.addVertex('袜子')
    topological.addVertex('鞋')
    topological.addVertex('手表')
    topological.addEdge('袜子','鞋')
    topological.addEdge('短裤','鞋')
    topological.addEdge('短裤','长裤')
    topological.addEdge('长裤','鞋')
    topological.addEdge('长裤','腰带')
    topological.addEdge('衬衫','腰带')
    topological.addEdge('衬衫','领带')
    topological.addEdge('领带','外套')
    topological.addEdge('腰带','外套')
    x = topological.topological_sort_bfs()
    print(x)
    x = topological.topological_sort_dfs()
    print(x)
    #输出
    #['短裤', '衬衫', '袜子', '手表', '长裤', '领带', '鞋', '腰带', '外套']
    #['手表', '袜子', '衬衫', '领带', '短裤', '长裤', '腰带', '外套', '鞋']

强连通分量

    #逆序图
    def reverse(self):
        new = Graph()
        for u in self:
            new.addVertex(u.getId())
        for u in self:
            for v in u.getConnections():
                new.addEdge(v.getId(),u.getId(),u.getWeight(v))
        new.InDegreeUpdate()
        new.OutDegreeUpdate()
        return new

    def Strongly_Connected_Component(self):
        R = []
        G_r = self.reverse()
        L = G_r.dfs()
        for i in G_r:
            i.setColor('white')
        L_scc = []
        L.reverse()
        for i in L:
            if self.vertList[i].getColor() == 'white':
                self.dfsvisit(self.getVertex(i), L_scc)
                R.append(L_scc)
                L_scc = []
        return R

测试

在这里插入图片描述

if __name__ == '__main__':
    #强联通分量测试
    scc = Graph()
    for i in range(1,11):
        scc.addVertex(i)
    scc.addEdge(1,10)
    scc.addEdge(10,1)
    scc.addEdge(1,3)
    scc.addEdge(3,4)
    scc.addEdge(4,1)
    scc.addEdge(8,10)
    scc.addEdge(8,9)
    scc.addEdge(9,8)
    scc.addEdge(9,7)
    scc.addEdge(7,7)
    scc.addEdge(3,7)
    scc.addEdge(4,6)
    scc.addEdge(6,5)
    scc.addEdge(5,2)
    scc.addEdge(2,6)
    R = scc.Strongly_Connected_Component()
    print(R)
    #输出
    #[[7], [5, 6, 2], [10, 4, 3, 1], [9, 8]]

后记

主要是巩固一下python的编程能力，顺便复习一下数据结构与算法。
后续有精力把算法导论里的算法补全。
创造不易，请多多支持。

参考书目

1.中国大学MOOC北航《算法设计与分析》
2.Python数据结构与算法分析（第二版）

整体代码

import queue
import sys
import os
import unittest

inf = 65535
GRAY = 0
WHITE = -1
BLACK = 1


class DisjointSet:

    def __init__(self, element=None):
        self._father = {}
        self._rank = {}
        # 初始化时每个元素单独成为一个集合
        if element is not None:
            for i in element:
                self.add(i)

    def add(self, x):
        # 添加新集合
        # 如果已经存在则跳过
        if x in self._father:
            return
        self._father[x] = x
        self._rank[x] = 0

    def _query(self, x):
        # 如果father[x] == x，说明x是树根
        if self._father[x] == x:
            return x
        self._father[x] = self._query(self._father[x])
        return self._father[x]

    def merge(self, x, y):
        if x not in self._father:
            self.add(x)
        if y not in self._father:
            self.add(y)
        # 查找到两个元素的树根
        x = self._query(x)
        y = self._query(y)
        # 如果相等，说明属于同一个集合
        if x == y:
            return
        # 否则将树深小的合并到树根大的上
        if self._rank[x] < self._rank[y]:
            self._father[x] = y
        else:
            self._father[y] = x
            # 如果树深相等，合并之后树深+1
            if self._rank[x] == self._rank[y]:
                self._rank[x] += 1

    # 判断是否属于同一个集合
    def same(self, x, y):
        return self._query(x) == self._query(y)



class Vertex:
    '''
    创建一个空顶点
    '''
    def __init__(self,key):
        self.id = key
        self.connectedTo = {}
        self.color = 'white'
        self.dist = inf
        self.pred = None
        self.InDegree = 0
        self.OutDegree = 0

        self.disc = 0
        self.fin = 0
    def addNeighbor(self, nbr, weight = 0):
        '''
        添加邻接的顶点
        :param nbr: 邻接的顶点
        :param weight: 默认为0
        :return:
        '''
        self.connectedTo[nbr] = weight
        self.OutDegree += 1

    def getConnections(self):
        '''
        获取邻接的所以顶点
        :return:
        '''
        return self.connectedTo.keys()
    def getId(self):
        '''
        获取自身顶点的值
        :return:
        '''
        return self.id
    def getWeight(self, nbr):
        '''
        两顶点连接边的权重
        :param nbr:
        :return:
        '''
        return self.connectedTo[nbr]

    def setColor(self, color):
        '''
        设置顶点的颜色（一般设置为白色表示未访问，灰色表示待处理，黑色表示访问完成）。
        :param color: 字符串、或者int 例如 color = 'white' color = -1
        :return:
        '''
        self.color = color

    def getColor(self):
        '''
        获取顶点的颜色，（一般设置为白色表示未访问，灰色表示待处理，黑色表示访问完成）
        :return:
        '''
        return self.color

    def setDistance(self, d):
        '''
        设置顶点距离，（不同算法有不同的意义）如单源最短路径表示源点到该点最短距离，最小生成树表示离该顶点最小的权重。
        :param d:
        :return:
        '''
        self.dist = d

    def getDistance(self):
        '''
        获取该顶点的距离，（不同算法有不同的意义）如单源最短路径表示源点到该点最短距离，最小生成树表示离该顶点最小的权重。
        :return:
        '''
        return self.dist


    def setPred(self, p):
        '''
        设置该顶点的前驱顶点
        :param p:
        :return:
        '''
        self.pred = p

    def getPred(self):
        '''
        设置该顶点的前驱顶点
        :return:
        '''
        return self.pred


    ##以下方法用得不多，帮助理解。

    def setDiscovery(self, dtime):
        '''
        设置顶点发现时间。
        :param dtime:
        :return:
        '''
        self.disc = dtime
    def getDiscovery(self):
        '''
        获取顶点发现时间。
        :return:
        '''
        return self.disc

    def setFinish(self, ftime):
        '''
        设置顶点完成时间。
        :param ftime:
        :return:
        '''
        self.fin = ftime

    def getFinish(self):
        '''
        获取顶点完成时间。
        :return:
        '''
        return self.fin









    # def __str__(self):
    #     return str(self.id) + ":color " + self.color + ":disc " + str(self.disc) + ":fin " + str(
    #         self.fin) + ":dist " + str(self.dist) + ":pred \n\t[" + str(self.pred) + "]\n"
    def __str__(self):
        return str(self.id) + ":color " + self.color + ":disc " + str(self.disc) + ":fin " + str(
            self.fin) + ":dist " + str(self.dist) + ":pred \n\t[" + str(self.pred) + "]\n"




class Graph:
    '''
    新建一个空图。
    '''
    def __init__(self):
        '''
        初始化邻接表，顶点个数
        '''
        self.vertList = {}
        self.numVertices = 0
        self.time = 0
        self.InDegreeList = {}
        self.OutDegreeList = {}
    def addVertex(self, key):
        '''
        向图中添加一个顶点实例
        :param key:
        :return: None
        '''
        self.numVertices = self.numVertices + 1
        newVertex = Vertex(key)
        self.vertList[key] = newVertex
        return newVertex

    def getVertex(self, n):
        '''
        在图中找到名为n的顶点
        :param n:
        :return:
        '''
        if n in self.vertList:
            return self.vertList[n]
        else:
            return None
    def __contains__(self,n):
        '''
        对in进行重载
        :param n:
        :return:
        '''
        return n in self.vertList
    def addEdge(self, f, t, weight = 0):
        '''
        )向图中添加一条带权重cost的有向边，用于连接顶点f和t
        :param f:
        :param t:
        :param weight:
        :return: None
        '''
        if f not in self.vertList:
            nv = self.addVertex(f)
        if t not in self.vertList:
            nv = self.addVertex(t)
        self.vertList[f].addNeighbor(self.vertList[t],weight)

    def getVertics(self):
        '''
        以列表形式返回图中所有顶点
        :return: {}.keys()
        '''
        return self.vertList.keys()
    def __iter__(self):
        '''
        对迭代进行重载，方便遍历顶点邻接表
        :return:
        '''
        return iter(self.vertList.values())

    def getOutDegrees(self,vertex):
        '''
        获取某个顶点出度
        :param vertex:
        :return:
        '''

        return self.vertList[vertex].OutDegree

    def getInDegrees(self,vertex):
        '''
        获取某个顶点的入度（很蠢的一个做法哈哈）
        :param vertex:
        :return:
        '''
        #初始化完后遍历查找
        self.vertList[vertex].InDegree = 0
        for u in self:
            if self.vertList[vertex] in u.getConnections():
                self.vertList[vertex].InDegree += 1

        return self.vertList[vertex].InDegree
    def OutDegreeUpdate(self):
        for u in self:
            self.OutDegreeList[u.getId()] = len(u.getConnections())
    def InDegreeUpdate(self):
        for u in self:
            self.InDegreeList[u.getId()] = 0

        for u in self:
            for v in u.getConnections():
                self.InDegreeList[v.getId()] += 1




    def bfs(self,start = None):
        '''
        广度优先搜索
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]
        start.setDistance(0)
        start.setPred(None)
        vertQueue = queue.Queue()
        vertQueue.put(start)
        out = []
        while vertQueue.empty() == False:
            currentVert = vertQueue.get()
            for nbr in currentVert.getConnections():
                if nbr.getColor() == 'white':
                    nbr.setColor('gray')
                    nbr.setDistance(currentVert.getDistance() + 1)
                    nbr.setPred(currentVert.getId())
                    vertQueue.put(nbr)
            currentVert.setColor('black')
            out.append(currentVert.getId())
        return out

    def dfs(self):
        '''
        深度优先搜索
        :return:
        '''
        out = []
        self.time = 0
        for aVertex in self:
            aVertex.setColor('white')
            aVertex.setPred(None)
        for aVertex in self:
            if aVertex.getColor() == 'white':
                self.dfsvisit(aVertex,out)
        return out

    def dfsvisit(self, startVertex,out):
        startVertex.setColor('gray')
        self.time += 1
        startVertex.setDiscovery(self.time)
        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'white':
                nextVertex.setPred(startVertex.getId())
                self.dfsvisit(nextVertex,out)
        startVertex.setColor('black')
        self.time += 1
        startVertex.setFinish(self.time)
        out.append(startVertex.getId())


    def dfs_stack(self,start = None):
        '''
        用栈实现dfs 该方法在某些情况下会失效 比如遍历生成拓扑排序
        :param start:
        :return:
        '''
        from collections import deque
        stack = deque()
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setColor('white')
            v.setPred(None)
        stack.append(start)

        while len(stack) > 0:
            currentVert = stack.pop()
            for nbr in currentVert.getConnections():
                if nbr.getColor() == 'white':
                    stack.append(nbr)
                    nbr.setPred(currentVert.getId())
                    nbr.setColor('balck')


    def prim_simple(self,start = None):
        '''
        prim最小生成树简单版本
        :param start: 迭代起点
        :return:
        '''
        #在有向图中，有可能存在这样一种情况：两个节点之间来和回的权重不一样
        #所以prim在某些情况下会失效
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)

        for i in range(self.numVertices):
            minDist = inf
            rec = -1
            # rec = 0
            for j in self:
                if j.getColor() == 'white' and j.getDistance() < minDist:
                    minDist = j.getDistance()
                    rec = j
            print(('%s,%d')%(rec.getId(),rec.getDistance()))
            for u in rec.getConnections():
                if rec.getWeight(u) < u.getDistance():
                    u.setDistance(rec.getWeight(u))
                    # print(('%s,%s,%d')%(rec.getId(),u.getId(),rec.getWeight(u)))
                    u.setPred(rec.getId())

            rec.setColor('black')

            # for u in rec.getConnections():
            #     newCost = rec.getWeight(u) + rec.getDistance()
            #     if newCost < u.getDistance():
            #         u.setDistance(newCost)
            #         u.setPred(rec.getId())
            # rec.setColor('black')


    def prim(self,start = None):
        '''
        prim最小生成树（采用优先队列）
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)
        pq = queue.PriorityQueue()

        for v in list(self.getVertics()):

            pq.put((self.vertList[v].getDistance(),v))


        while not pq.empty():
            (t, currentVert) = pq.get()
            currentVert = self.vertList[currentVert]
            for nextVert in currentVert.getConnections():
                newCost = currentVert.getWeight(nextVert)
                if newCost < nextVert.getDistance() and nextVert.getColor() == 'white':
                    nextVert.setPred(currentVert.getId())
                    nextVert.setDistance(newCost)
                    pq.put((newCost, nextVert.id))
            currentVert.setColor('black')


    def dijkstra(self,start = None):
        '''
        dijkstra单源最短路径（使用优先队列）
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]


        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')

        start.setDistance(0)
        pq = queue.PriorityQueue()
        for v in list(self.getVertics()):
            pq.put((self.vertList[v].getDistance(),v))

        while not pq.empty():
            (t, currentVert) = pq.get()
            currentVert = self.vertList[currentVert]
            for nextVert in currentVert.getConnections():
                newDist = currentVert.getWeight(nextVert) + currentVert.getDistance()
                if newDist < nextVert.getDistance() and nextVert.getColor() == 'white':
                    nextVert.setPred(currentVert.getId())
                    nextVert.setDistance(newDist)
                    pq.put((newDist, nextVert.id))

            currentVert.setColor('black')
    def dijkstra_simple(self,start = None):
        '''
         dijkstra单源最短路径简单版本
        :param start:
        :return:
        '''
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)

        for i in range(self.numVertices):
            minDist = inf
            rec = 0
            for j in self:
                if j.getColor() == 'white' and j.getDistance() < minDist:
                    minDist = j.getDistance()
                    rec = j
            for u in rec.getConnections():
                if rec.getDistance() + rec.getWeight(u) < u.getDistance():
                    u.setDistance(rec.getDistance() + rec.getWeight(u))
                    u.setPred(rec.getId())
            rec.setColor('black')


    def bellman_ford(self,start = None):
        '''
        bellman_ford算法
        :param start:
        :return:
        '''
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        #可以用这种方法遍历 不过比较繁琐。
        # for v in self.getVertics():
        #     self.vertList[v].setDistance(inf)
        #     self.vertList[v].setPred(None)
        #     pred[v] = None
        for v in self:
            v.setDistance(inf)
            v.setPred(None)


        start.setDistance(0)
        for i in range(self.numVertices-1):
            for v in self:
                for u in v.getConnections():
                    print("(%s,%s,%s)" % (v.getId(), u.getId(), v.getWeight(u)))
                    if v.getDistance() + v.getWeight(u) < u.getDistance():
                        u.setDistance(v.getDistance() + v.getWeight(u))
                        u.setPred(v.getId())


        for v in self:
            for u in v.getConnections():
                if v.getDistance() + v.getWeight(u) < u.getDistance():
                    print("存在负环")
                    return False
                    break
        return True


    def kruskal(self):
        '''
        kruskal算法使用并查集类
        :return:
        '''
        disjoinset = DisjointSet([key.getId() for key in self])
        edges = []
        for v in self:
            for u in v.getConnections():
                edges.append((v.getId(),u.getId(),v.getWeight(u)))

        edges.sort(key = lambda a:a[2])

        minu_tree = []
        for edge in edges:
            u, v, w = edge
            if disjoinset.same(u, v):
                continue
            disjoinset.merge(u, v)
            self.getVertex(v).setPred(u)
            minu_tree.append(edge)
        for edge in minu_tree:
            self.getVertex(u)

        return minu_tree

    def dfs_judge_cycle(self):

        for aVertex in self:
            aVertex.setColor('white')
            aVertex.setPred(-1)
        for aVertex in self:
            if aVertex.getColor() == 'white':
                if self.dfs_visit_judge_cycle(aVertex) == True:
                    return True
        return False

    def dfs_visit_judge_cycle(self, startVertex):
        startVertex.setColor('gray')
        startVertex.setDiscovery(self.time)
        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'gray':
                return True
            if nextVertex.getColor() == 'white':
                nextVertex.setPred(startVertex.getId())
                if self.dfs_visit_judge_cycle(nextVertex) == True:
                    return True

            startVertex.setColor('black')

    def topological_sort_bfs(self):

        self.InDegreeUpdate()
        vertQueue = queue.Queue()
        out = []

        for v in self:
            if self.InDegreeList[v.getId()] == 0:
                vertQueue.put(v)

        while vertQueue.empty() == False:
            currentVert = vertQueue.get()
            # print(currentVert.getId(),end=" ")
            out.append(currentVert.getId())
            for nbr in currentVert.getConnections():
                self.InDegreeList[nbr.getId()] = self.InDegreeList[nbr.getId()] - 1
                if self.InDegreeList[nbr.getId()] == 0:
                    vertQueue.put(nbr)
        # print()
        # print(out)
        return out

    def topological_sort_dfs(self):

        self.out = []
        L = []
        for aVertex in self:
            aVertex.setColor('white')
        for aVertex in self:
            if aVertex.getColor() == 'white':
                self.topological_sort_dfs_visit(aVertex, L)
        L.reverse()
        return L

    def topological_sort_dfs_visit(self, startVertex, L):

        startVertex.setColor('gray')

        for nextVertex in startVertex.getConnections():
            if nextVertex.getColor() == 'white':
                self.topological_sort_dfs_visit(nextVertex, L)
        startVertex.setColor('black')
        L.append(startVertex.getId())

    def Strongly_Connected_Component(self):
        R = []
        G_r = self.reverse()
        L = G_r.dfs()
        for i in G_r:
            i.setColor('white')
        L_scc = []
        L.reverse()
        for i in L:
            if self.vertList[i].getColor() == 'white':
                self.dfsvisit(self.getVertex(i), L_scc)
                R.append(L_scc)
                L_scc = []
        return R

    def reverse(self):
        new = Graph()
        for u in self:
            new.addVertex(u.getId())
        for u in self:
            for v in u.getConnections():
                new.addEdge(v.getId(),u.getId(),u.getWeight(v))
        new.InDegreeUpdate()
        new.OutDegreeUpdate()
        return new

    ###以下内容学习副产物 可以略过
    def prim_other(self,start = None):
        if start == None:
            #若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        for v in self:
            v.setDistance(inf)
            v.setPred(None)
            v.setColor('white')
        start.setDistance(0)
        pq = queue.PriorityQueue()

        for v in list(self.getVertics()):

            pq.put((self.vertList[v].getDistance(),v))


        while not pq.empty():
            (t, currentVert) = pq.get()
            currentVert = self.vertList[currentVert]
            for nextVert in currentVert.getConnections():
                newCost = currentVert.getWeight(nextVert) + currentVert.getDistance()
                if newCost < nextVert.getDistance() and nextVert.getColor() == 'white':
                    nextVert.setPred(currentVert.getId())
                    nextVert.setDistance(newCost)
                    pq.put((newCost, nextVert.id))
            currentVert.setColor('black')



    def BFS(self, s = None):
        if s == None:
            #若是未指定远点 默认取第一个顶点
            s = list(self.getVertics())[0]
        color = {}
        pred = {}
        dist = {}
        queue = []
        out = []
        for i in self.vertList:
            color[i] = WHITE
            dist[i] = inf
            pred[i] = -1

        color[s] = GRAY
        dist[s] = 0
        queue.append(s)
        while queue:
            u = queue.pop(0)
            for i in list(self.vertList[u].getConnections()):
                print(i)
                if color[i.id] == WHITE:
                    color[i.id] = GRAY
                    dist[i.id] = dist[u] + 1
                    pred[i.id] = u
                    queue.append(i.id)

            color[u] = BLACK
            out.append(u)

        print(out)
        print(pred.values())
        print(dist.values())
        return out,pred,dist

    def kruskal_simple(self):
        '''
        kruskal算法简约写法（未用类）
        :return:
        '''
        X = dict()
        R = dict()  # 各点的初始等级均为0,如果被做为连接的的末端，则增加1

        def make_set(point):
            X[point] = point
            R[point] = 0

        def find(point):
            if X[point] != point:
                X[point] = find(X[point])
            return X[point]

        def merge(point1, point2):
            '''连接两个分量（节点）
            '''
            r1 = find(point1)
            r2 = find(point2)
            if r1 != r2:
                if R[r1] > R[r2]:
                    X[r2] = r1
                else:
                    X[r1] = r2
                    if R[r1] == R[r2]:
                        R[r2] += 1

        edges = []
        for v in self:
            for u in v.getConnections():
                edges.append((v.getId(), u.getId(), v.getWeight(u)))
        print(edges)

        edges.sort(key=lambda a: a[2])
        print(edges)  # 按照权重从小到大排序

        for v in g:
            make_set(v.getId())
        minu_tree = []
        for edge in edges:
            v, u, weight = edge
            if find(v) != find(u):
                merge(v, u)
                self.getVertex(u).setPred(v)
                minu_tree.append(edge)
        return minu_tree


    def topological_sort_dfs_stack(self,start = None):
        from collections import deque
        stack = deque()
        if start == None:
            # 若是未指定远点 默认取第一个顶点
            start = self.vertList[list(self.getVertics())[0]]

        L = []
        for v in self:
            v.setColor('white')
        stack.append(start)

        while len(stack) > 0:
            currentVert = stack.pop()
            print(currentVert.getId())
            for nbr in currentVert.getConnections():
                print(nbr.getId())
                if nbr.getColor() == 'white':
                    stack.append(nbr)
                    nbr.setColor('balck')
            L.append(currentVert.getId())
        return L




def traverse(y):
    x = y
    while x.getPred():
        print(x.getId())
        x = x.getPred()
    print(x.getId)




# if __name__ == '__main__':
#     #强联通分量测试
#     scc = Graph()
#     for i in range(1,11):
#         scc.addVertex(i)
#     scc.addEdge(1,10)
#     scc.addEdge(10,1)
#     scc.addEdge(1,3)
#     scc.addEdge(3,4)
#     scc.addEdge(4,1)
#     scc.addEdge(8,10)
#     scc.addEdge(8,9)
#     scc.addEdge(9,8)
#     scc.addEdge(9,7)
#     scc.addEdge(7,7)
#     scc.addEdge(3,7)
#     scc.addEdge(4,6)
#     scc.addEdge(6,5)
#     scc.addEdge(5,2)
#     scc.addEdge(2,6)
#     R = scc.Strongly_Connected_Component()
#     print(R)

# if __name__ == '__main__':
#
#     #拓扑排序测试
#     topological = Graph()
#     topological.addVertex('短裤')
#     topological.addVertex('长裤')
#     topological.addVertex('腰带')
#     topological.addVertex('衬衫')
#     topological.addVertex('领带')
#     topological.addVertex('外套')
#     topological.addVertex('袜子')
#     topological.addVertex('鞋')
#     topological.addVertex('手表')
#     topological.addEdge('袜子','鞋')
#     topological.addEdge('短裤','鞋')
#     topological.addEdge('短裤','长裤')
#     topological.addEdge('长裤','鞋')
#     topological.addEdge('长裤','腰带')
#     topological.addEdge('衬衫','腰带')
#     topological.addEdge('衬衫','领带')
#     topological.addEdge('领带','外套')
#     topological.addEdge('腰带','外套')
#     x = topological.topological_sort_bfs()
#     print(x)
#     x = topological.topological_sort_dfs()
#     print(x)

# if __name__ =='__main__':
#
#     bellman = Graph()
#     bellman.addVertex('s')
#     bellman.addVertex('t')
#     bellman.addVertex('x')
#     bellman.addVertex('y')
#     bellman.addVertex('z')
#     bellman.addEdge('s','t',6)
#     bellman.addEdge('s','y',7)
#     bellman.addEdge('t','x',5)
#     bellman.addEdge('x','t',-2)
#     bellman.addEdge('t','z',-4)
#     bellman.addEdge('t','y',8)
#     bellman.addEdge('y','z',2)
#     bellman.addEdge('y','x',-3)
#     bellman.addEdge('x','z',7)
#     bellman.bellman_ford()
#     for v in bellman:
#         print(v)
#     for v in bellman:
#         print(v.getPred(),end = ' ')
#     print()
#     for v in bellman:
#         print(v.getDistance(),end = ' ')
#     print()

# if __name__ =='__main__':
#
#     g = Graph()
#     g.addVertex('s')
#     g.addVertex('t')
#     g.addVertex('x')
#     g.addVertex('y')
#     g.addVertex('z')
#     g.addEdge('s','t',8)
#     g.addEdge('s','y',5)
#     g.addEdge('t','x',1)
#     g.addEdge('t','y',2)
#     g.addEdge('x','z',4)
#     g.addEdge('y','t',3)
#     g.addEdge('y','z',2)
#     g.addEdge('y','x',9)
#     g.addEdge('z','x',6)
#     g.dijkstra()
#     for v in g:
#         print(v)
#     for v in g:
#         print(v.getPred(),end = ' ')
#     print()
#     for v in g:
#         print(v.getDistance(),end = ' ')
#     print()
#
#     g.dijkstra_simple()
#     for v in g:
#         print(v)
#     for v in g:
#         print(v.getPred(),end = ' ')
#     print()
#     for v in g:
#         print(v.getDistance(),end = ' ')
#     print()

# if __name__ =='__main__':
#
#     g = Graph()
#     g.addVertex('a')
#     g.addVertex('b')
#     g.addVertex('c')
#     g.addVertex('d')
#     g.addVertex('f')
#     g.addVertex('h')
#     g.addVertex('g')
#     g.addVertex('i')
#     g.addVertex('z')
#     g.addEdge('a','b',4)
#     g.addEdge('b','a',4)
#     g.addEdge('a','h',8)
#     g.addEdge('h','a',8)
#     g.addEdge('b','c',8)
#     g.addEdge('c','b',8)
#     g.addEdge('b','h',1)
#     g.addEdge('h','b',1)
#     g.addEdge('h','i',7)
#     g.addEdge('i','h',7)
#     g.addEdge('c','i',2)
#     g.addEdge('i','c',2)
#     g.addEdge('c','d',7)
#     g.addEdge('d','c',7)
#     g.addEdge('i','g',4)
#     g.addEdge('g','i',4)
#     g.addEdge('g','f',2)
#     g.addEdge('f','g',2)
#     g.addEdge('f','z',10)
#     g.addEdge('z','f',10)
#     g.addEdge('d','f',14)
#     g.addEdge('f','d',14)
#     g.addEdge('d','z',9)
#     g.addEdge('z','d',9)
#     g.addEdge('c','f',6)
#     g.addEdge('f','c',6)
#     g.addEdge('h','g',1)
#     g.addEdge('g','h',1)
#     g.prim()
#     for v in g:
#         print(v)
#     for v in g:
#         print(v.getPred(),end = ' ')
#     print()
#     for v in g:
#         print(v.getDistance(),end = ' ')
#     print()
#
#     g.prim_simple()
#     for v in g:
#         print(v)
#     for v in g:
#         print(v.getPred(),end = ' ')
#     print()
#     for v in g:
#         print(v.getDistance(),end = ' ')
#     print()
#     x = g.kruskal()
#     print(x)

if __name__ =='__main__':

    g = Graph()
    for i in range(1,9):
        g.addVertex(i)
    g.addEdge(1,2)
    g.addEdge(2,1)
    g.addEdge(1,5)
    g.addEdge(5,1)
    g.addEdge(2, 6)
    g.addEdge(6,2)
    g.addEdge(6, 3)
    g.addEdge(3,6)
    g.addEdge(6, 7)
    g.addEdge(7,6)
    g.addEdge(3, 7)
    g.addEdge(7,3)
    g.addEdge(3, 4)
    g.addEdge(4,3)
    g.addEdge(4, 8)
    g.addEdge(4,7)
    g.addEdge(7,4)
    g.addEdge(8,4)
    g.addEdge(7, 8)
    g.addEdge(8,7)


    g.bfs(g.vertList[2])
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()

    x = g.dfs()
    print(x)
    for v in g:
        print(v)
    for v in g:
        print(v.getPred(),end = ' ')
    print()
    for v in g:
        print(v.getDistance(),end = ' ')
    print()
    for v in g:
        print(v.getDiscovery(),end = ' ')
    print()
    for v in g:
        print(v.getFinish(),end = ' ')
    print()