python数据结构之图

最新推荐文章于 2024-04-01 00:33:44 发布
最新推荐文章于 2024-04-01 00:33:44 发布
阅读量757 收藏 8
点赞数
文章标签： python java 数据结构 数据挖掘 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baoqiangwang/article/details/118887111
版权

在数学中，图是描述于一组对象的结构，其中某些对象对在某种意义上是“相关的”。这些对象对应于称为顶点的数学抽象（也称为节点或点），并且每个相关的顶点对都称为边（也称为链接或线）。通常，图形以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。--百度百科

networkx是一个python包，用于创建、操作和研究复杂网络的结构、动态和功能。

图是一种比较复杂的数据结构，包括了一整套数学逻辑，实现起来过于复杂，还是直接用现成的networkx就好。

NetworkX提供：研究社会、生物和基础设施网络结构和动态的工具；一种适用于多种应用的标准编程接口和图形实现；为协作性、多学科项目提供快速发展环境；与现有的数值算法和C、C++和FORTRAN代码的接口；能够轻松处理大型非标准数据集。使用NetworkX，您可以以标准和非标准数据格式加载和存储网络，生成多种类型的随机和经典网络，分析网络结构，构建网络模型，设计新的网络算法，绘制网络，等等

要实现的图的边和节点示意如下，不过在实现的过程中均以无向图为主。

代码主体结构如下：

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#                     _ooOoo_
#                   o8888888o
#                    88" . "88
#                 ( | -  _  - | )
#                     O\ = /O
#                 ____/`---'\____
#                  .' \\| |// `.
#                 / \\|||:|||// \
#               / _|||||-:- |||||- \
#                | | \\\ - /// | |
#              | \_| ''\---/'' | _/ |
#               \ .-\__ `-` ___/-. /
#            ___`. .' /--.--\ `. . __
#         ."" '< `.___\_<|>_/___.' >'"".
#       | | : `- \`.;`\  _ /`;.`/ - ` : | |
#          \ \ `-. \_ __\ /__ _/ .-` / /
#      ==`-.____`-.___\_____/___.-`____.-'==
#                     `=---='
'''
@Project ：pythonalgorithms 
@File ：graphdatastructure.py
@Author ：不胜人生一场醉
@Date ：2021/7/16 22:18 
'''

import networkx as nx
import matplotlib.pyplot as plt


if __name__ == "__main__":
    testSimpleGraph()
    testGraphaddfrom()
    testGraphlabelpic()
    testGraphpospic()
    testGraphfunc()
    testGraphAlgorithms()

1、实现一个简单的无向图，并绘制出来

def testSimpleGraph():
    g = nx.Graph()  # 创建空的无向图
    # g = nx.DiGraph()  # 创建空的有向图
    g.add_node(1)
    g.add_node(2)
    g.add_node(3)
    g.add_node(4)
    g.add_edge(1, 2)
    g.add_edge(1, 3)
    g.add_edge(2, 3)
    g.add_edge(3, 4)
    nx.draw_networkx(g)
    plt.show()

结果如下：

2、通过列表实现无向图，并绘制出来：

def testGraphaddfrom():
    g = nx.Graph()  # 创建空的无向图
    g.add_nodes_from([1, 2, 3, 4, 5, 6, 7])
    g.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (1, 6),
                      (2, 3), (2, 4), (2, 6),
                      (3, 6),
                      (4, 5),
                      (5, 6),
                      (6, 7)])
    nx.draw_networkx(g)
    plt.show()

结果如下：

3、在图可视化中追加节点标签和边的标签

def testGraphlabelpic():
    # 数组，7个节点，13条边，有向图
    #   a   b   c   d   e   f   g
    # a     4   7   4   7   8
    # b         4   5       6
    # c         `           3
    # d                 2
    # e                     5
    # f                         8
    # g
    g = nx.Graph()
    g.add_nodes_from([
        (1, {"name": "a"}),
        (2, {"name": "b"}),
        (3, {"name": "c"}),
        (4, {"name": "d"}),
        (5, {"name": "e"}),
        (6, {"name": "f"}),
        (7, {"name": "g"}),
    ])
    g.add_edges_from([(1, 2, {'weight': 4}),
                      (1, 3, {'weight': 7}),
                      (1, 4, {'weight': 4}),
                      (1, 5, {'weight': 7}),
                      (1, 6, {'weight': 8}),
                      (2, 3, {'weight': 4}),
                      (2, 4, {'weight': 5}),
                      (2, 6, {'weight': 6}),
                      (3, 6, {'weight': 3}),
                      (4, 5, {'weight': 2}),
                      (5, 6, {'weight': 5}),
                      (6, 7, {'weight': 8})
                      ])

    pos = nx.spring_layout(g)
    # 调用draw(G, pos)将基础的点边拓扑先画出来
    nx.draw(g, pos)
    node_labels = nx.get_node_attributes(g, 'name')
    # {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g'}
    # 调用draw_networkx_labels画节点标签
    nx.draw_networkx_labels(g, pos, labels=node_labels)
    edge_labels = nx.get_edge_attributes(g, 'weight')
    # {(1, 2): 4, (1, 3): 7, (1, 4): 4, (1, 5): 7, (1, 6): 8, (2, 3): 4, (2, 4): 5, (2, 6): 6, (3, 6): 3, (4, 5): 2, (5, 6): 5, (6, 7): 8}
    # 调用draw_networkx_edge_labels画和边的标签。
    nx.draw_networkx_edge_labels(g, pos, edge_labels=edge_labels)
    plt.show()

结果如下：

4、在图可视化中继续追加节点的位置和边的权重

def testGraphpospic():
    # 数组，7个节点，13条边，有向图
    #   a   b   c   d   e   f   g
    # a     4   7   4   7   8
    # b         4   5       6
    # c         `           3
    # d                 2
    # e                     5
    # f                         8
    # g
    g = nx.Graph()
    g.add_nodes_from([
        (1, {"name": "a", "pos": (3, 17), "degree": 5, "out_degree": 5, "in_degree": 0}),
        (2, {"name": "b", "pos": (1, 13), "degree": 4, "out_degree": 3, "in_degree": 1}),
        (3, {"name": "c", "pos": (2, 8), "degree": 2, "out_degree": 1, "in_degree": 1}),
        (4, {"name": "d", "pos": (5, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (5, {"name": "e", "pos": (7, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (6, {"name": "f", "pos": (5, 8), "degree": 5, "out_degree": 1, "in_degree": 4}),
        (7, {"name": "g", "pos": (7, 1), "degree": 1, "out_degree": 0, "in_degree": 1})
    ])

    g.add_edges_from([(1, 2, {'weight': 4}),
                      (1, 3, {'weight': 7}),
                      (1, 4, {'weight': 4}),
                      (1, 5, {'weight': 7}),
                      (1, 6, {'weight': 8}),
                      (2, 3, {'weight': 4}),
                      (2, 4, {'weight': 5}),
                      (2, 6, {'weight': 6}),
                      (3, 6, {'weight': 3}),
                      (4, 5, {'weight': 2}),
                      (5, 6, {'weight': 5}),
                      (6, 7, {'weight': 8})
                      ])

    # 获取节点位置
    pos = nx.get_node_attributes(g, 'pos')
    # {1: (3, 17), 2: (1, 13), 3: (2, 8), 4: (5, 13), 5: (7, 13), 6: (5, 8), 7: (7, 1)}
    # 获取节点大小值=出入度*100
    nodesize = list(nx.get_node_attributes(g, 'degree').values())
    nodesize = [i * 100 for i in nodesize]
    # 调用draw(G, pos)将基础的点边拓扑先画出来
    nx.draw(g, pos, node_size=nodesize)
    # 获取节点标签名称
    node_labels = nx.get_node_attributes(g, 'name')
    # {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g'}
    # 调用draw_networkx_labels画节点标签
    nx.draw_networkx_labels(g, pos, labels=node_labels)
    # 获取边的标签名称
    edge_labels = nx.get_edge_attributes(g, 'weight')
    # {(1, 2): 4, (1, 3): 7, (1, 4): 4, (1, 5): 7, (1, 6): 8, (2, 3): 4, (2, 4): 5, (2, 6): 6, (3, 6): 3, (4, 5): 2, (5, 6): 5, (6, 7): 8}
    # 调用draw_networkx_edge_labels画和边的标签。
    nx.draw_networkx_edge_labels(g, pos, edge_labels=edge_labels)
    # 获取边的权重，即对长度进行转换
    edgewidth = list(nx.get_edge_attributes(g, 'weight').values())
    nx.draw_networkx_edges(g, pos, width=edgewidth)
    plt.show()

要

6、测试networkx中关于日常操作的基本函数

def testGraphfunc():
    # 数组，7个节点，13条边，有向图
    #   a   b   c   d   e   f   g
    # a     4   7   4   7   8
    # b         4   5       6
    # c         `           3
    # d                 2
    # e                     5
    # f                         8
    # g
    # 判断两节点间是否有边    Graph.has_edge(u, v)
    # 网络中结点的个数  G.number_of_nodes()
    # 网络中边的个数   G.number_of_edges()
    # 获取结点i的邻居节点    G.neighbors(i)  或   G[i]（在有向图中输出的是出度的邻居，G[i]会输出权重）
    # 获取所有节点的度  G.degree()
    # 获取节点i的属性  G.nodes[i]["wight"]
    # 查看图中所有点的信息    G.nodes.data()
    g = nx.Graph()
    g.add_nodes_from([
        (1, {"name": "a", "pos": (3, 17), "degree": 5, "out_degree": 5, "in_degree": 0, "wight": 5}),
        (2, {"name": "b", "pos": (1, 13), "degree": 4, "out_degree": 3, "in_degree": 1}),
        (3, {"name": "c", "pos": (2, 8), "degree": 2, "out_degree": 1, "in_degree": 1}),
        (4, {"name": "d", "pos": (5, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (5, {"name": "e", "pos": (7, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (6, {"name": "f", "pos": (5, 8), "degree": 5, "out_degree": 1, "in_degree": 4}),
        (7, {"name": "g", "pos": (7, 1), "degree": 1, "out_degree": 0, "in_degree": 1})
    ])

    g.add_edges_from([(1, 2, {'weight': 4}),
                      (1, 3, {'weight': 7}),
                      (1, 4, {'weight': 4}),
                      (1, 5, {'weight': 7}),
                      (1, 6, {'weight': 8}),
                      (2, 3, {'weight': 4}),
                      (2, 4, {'weight': 5}),
                      (2, 6, {'weight': 6}),
                      (3, 6, {'weight': 3}),
                      (4, 5, {'weight': 2}),
                      (5, 6, {'weight': 5}),
                      (6, 7, {'weight': 8})
                      ])
    # 判断两节点间是否有边    Graph.has_edge(u, v)
    print('节点2和节点4是否有边=', g.has_edge(2, 4))  # True
    print('节点3和节点4是否有边=', g.has_edge(3, 4))  # False
    # 网络中结点的个数  G.number_of_nodes()
    print('网络中结点的个数=', g.number_of_nodes())  # 7
    # 网络中边的个数   G.number_of_edges()
    print('网络中边的个数=', g.number_of_edges())  # 12
    # 获取结点i的邻居节点    G.neighbors(i)
    print('获取结点1的邻居节点=', g.neighbors(1))
    # 获取结点1的邻居节点= <dict_keyiterator object at 0x00000261558B2D10>
    print('获取结点1的邻居节点=', list(g.neighbors(1)))
    # 获取结点1的邻居节点= [2, 3, 4, 5, 6]
    # 获取所有节点的度  G.degree()
    print('获取所有节点的度=', g.degree())
    # 获取所有节点的度= [(1, 5), (2, 4), (3, 3), (4, 3), (5, 3), (6, 5), (7, 1)]
    # 获取节点i G.nodes[i]
    print('获取节点i=', g.nodes[1])
    # 获取节点i= {'name': 'a', 'pos': (3, 17), 'degree': 5, 'out_degree': 5, 'in_degree': 0, 'wight': 5}
    # 获取节点i的属性名 G.nodes[i]
    print('获取节点i的属性名=', list(g.nodes[1]))
    # 获取节点i= ['name', 'pos', 'degree', 'out_degree', 'in_degree', 'wight']
    # 获取节点i的属性值 = 5
    # 获取节点i的属性值 G.nodes[i]["wight"]
    print('获取节点i的属性值=', g.nodes[1]["wight"])
    # 获取节点i的属性 = 5
    # 查看图中所有点的信息    G.nodes.data()
    print('查看图中所有点的信息=', g.nodes.data())

    # 查看图中所有点的信息= [
    # (1, {'name': 'a', 'pos': (3, 17), 'degree': 5, 'out_degree': 5, 'in_degree': 0, 'wight': 5}),
    # (2, {'name': 'b', 'pos': (1, 13), 'degree': 4, 'out_degree': 3, 'in_degree': 1}),
    # (3, {'name': 'c', 'pos': (2, 8), 'degree': 2, 'out_degree': 1, 'in_degree': 1}),
    # (4, {'name': 'd', 'pos': (5, 13), 'degree': 3, 'out_degree': 1, 'in_degree': 2}),
    # (5, {'name': 'e', 'pos': (7, 13), 'degree': 3, 'out_degree': 1, 'in_degree': 2}),
    # (6, {'name': 'f', 'pos': (5, 8), 'degree': 5, 'out_degree': 1, 'in_degree': 4}),
    # (7, {'name': 'g', 'pos': (7, 1), 'degree': 1, 'out_degree': 0, 'in_degree': 1})]

结果如下：

节点2和节点4是否有边= True
节点3和节点4是否有边= False
网络中结点的个数= 7
网络中边的个数= 12
获取结点1的邻居节点= <dict_keyiterator object at 0x0000026FA0EC27C0>
获取结点1的邻居节点= [2, 3, 4, 5, 6]
获取所有节点的度= [(1, 5), (2, 4), (3, 3), (4, 3), (5, 3), (6, 5), (7, 1)]
获取节点i= {'name': 'a', 'pos': (3, 17), 'degree': 5, 'out_degree': 5, 'in_degree': 0, 'wight': 5}
获取节点i的属性名= ['name', 'pos', 'degree', 'out_degree', 'in_degree', 'wight']
获取节点i的属性值= 5
查看图中所有点的信息= [(1, {'name': 'a', 'pos': (3, 17), 'degree': 5, 'out_degree': 5, 'in_degree': 0, 'wight': 5}), (2, {'name': 'b', 'pos': (1, 13), 'degree': 4, 'out_degree': 3, 'in_degree': 1}), (3, {'name': 'c', 'pos': (2, 8), 'degree': 2, 'out_degree': 1, 'in_degree': 1}), (4, {'name': 'd', 'pos': (5, 13), 'degree': 3, 'out_degree': 1, 'in_degree': 2}), (5, {'name': 'e', 'pos': (7, 13), 'degree': 3, 'out_degree': 1, 'in_degree': 2}), (6, {'name': 'f', 'pos': (5, 8), 'degree': 5, 'out_degree': 1, 'in_degree': 4}), (7, {'name': 'g', 'pos': (7, 1), 'degree': 1, 'out_degree': 0, 'in_degree': 1})]
[(1, 2, {'weight': 4}), (1, 4, {'weight': 4}), (2, 3, {'weight': 4}), (3, 6, {'weight': 3}), (4, 5, {'weight': 2}), (6, 7, {'weight': 8})]
节点1-节点7最短路径= [1, 6, 7]

7、测试networkx中关于最短路径、连通性、各种遍历等算法功能：

def testGraphAlgorithms():
    # 数组，7个节点，13条边，有向图
    #   a   b   c   d   e   f   g
    # a     4   7   4   7   8
    # b         4   5       6
    # c         `           3
    # d                 2
    # e                     5
    # f                         8
    # g
    g = nx.Graph()
    g.add_nodes_from([
        (1, {"name": "a", "pos": (3, 17), "degree": 5, "out_degree": 5, "in_degree": 0, "wight": 5}),
        (2, {"name": "b", "pos": (1, 13), "degree": 4, "out_degree": 3, "in_degree": 1}),
        (3, {"name": "c", "pos": (2, 8), "degree": 2, "out_degree": 1, "in_degree": 1}),
        (4, {"name": "d", "pos": (5, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (5, {"name": "e", "pos": (7, 13), "degree": 3, "out_degree": 1, "in_degree": 2}),
        (6, {"name": "f", "pos": (5, 8), "degree": 5, "out_degree": 1, "in_degree": 4}),
        (7, {"name": "g", "pos": (7, 1), "degree": 1, "out_degree": 0, "in_degree": 1})
    ])

    g.add_edges_from([(1, 2, {'weight': 4}),
                      (1, 3, {'weight': 7}),
                      (1, 4, {'weight': 4}),
                      (1, 5, {'weight': 7}),
                      (1, 6, {'weight': 8}),
                      (2, 3, {'weight': 4}),
                      (2, 4, {'weight': 5}),
                      (2, 6, {'weight': 6}),
                      (3, 6, {'weight': 3}),
                      (4, 5, {'weight': 2}),
                      (5, 6, {'weight': 5}),
                      (6, 7, {'weight': 8})
                      ])

    # 最小生成树
    tree = nx.minimum_spanning_tree(g, algorithm='prim')
    print(tree.edges(data=True))
    # [(1, 2, {'weight': 4}),
    # (1, 4, {'weight': 4}),
    # (2, 3, {'weight': 4}),
    # (3, 6, {'weight': 3}),
    # (4, 5, {'weight': 2}),
    # (6, 7, {'weight': 8})]

    # 最短路径
    print("节点1-节点7最短路径=",nx.dijkstra_path(g, 1, 7))
    # [1, 6, 7]
    # 所有节点之间的最短路径
    gen = nx.all_pairs_shortest_path(g)
    print("所有节点之间的最短路径=",dict(gen))
    # {
    # 1: {1: [1], 2: [1, 2], 3: [1, 3], 4: [1, 4], 5: [1, 5], 6: [1, 6], 7: [1, 6, 7]},
    # 2: {2: [2], 1: [2, 1], 3: [2, 3], 4: [2, 4], 6: [2, 6], 5: [2, 1, 5], 7: [2, 6, 7]},
    # 3: {3: [3], 1: [3, 1], 2: [3, 2], 6: [3, 6], 4: [3, 1, 4], 5: [3, 1, 5], 7: [3, 6, 7]},
    # 4: {4: [4], 1: [4, 1], 2: [4, 2], 5: [4, 5], 3: [4, 1, 3], 6: [4, 1, 6], 7: [4, 1, 6, 7]},
    # 5: {5: [5], 1: [5, 1], 4: [5, 4], 6: [5, 6], 2: [5, 1, 2], 3: [5, 1, 3], 7: [5, 6, 7]},
    # 6: {6: [6], 1: [6, 1], 2: [6, 2], 3: [6, 3], 5: [6, 5], 7: [6, 7], 4: [6, 1, 4]},
    # 7: {7: [7], 6: [7, 6], 1: [7, 6, 1], 2: [7, 6, 2], 3: [7, 6, 3], 5: [7, 6, 5], 4: [7, 6, 1, 4]}}

    print("各点之间可达性=",nx.communicability(g))
    # 各点之间可达性= {
    # 1: {1: 11.66037697759954, 2: 9.730688193140374, 3: 8.180239781697592, 4: 7.645194148638486, 5: 7.720951055876168, 6: 10.188202427433492, 7: 2.4556767248680185},
    # 2: {1: 9.730688193140374, 2: 8.966431076518731, 3: 7.2767859598006615, 4: 6.497877866101427, 5: 6.132652147982442, 6: 8.800266284965774, 7: 2.136327166832645},
    # 3: {1: 8.180239781697592, 2: 7.2767859598006615, 3: 6.750798019391801, 4: 4.922928096425332, 5: 4.985335865445396, 6: 7.643419657110174, 7: 1.9072819535912968},
    # 4: {1: 7.645194148638486, 2: 6.497877866101427, 3: 4.922928096425332, 4: 5.962359580374006, 5: 5.4295610915115375, 6: 6.2992895922037295, 7: 1.3858918410969554},
    # 5: {1: 7.720951055876168, 2: 6.132652147982442, 3: 4.985335865445396, 4: 5.4295610915115375, 5: 6.053240117357615, 6: 6.892984331374484, 7: 1.7072857005030746},
    # 6: {1: 10.188202427433492, 2: 8.800266284965774, 3: 7.643419657110174, 4: 6.2992895922037295, 5: 6.892984331374484, 6: 10.11197286752748, 7: 3.0514157654095175},
    # 7: {1: 2.4556767248680185, 2: 2.136327166832645, 3: 1.9072819535912968, 4: 1.3858918410969554, 5: 1.7072857005030746, 6: 3.0514157654095175, 7: 1.9054013217324557}}


    print("获得图中非连通点的列表=",list(nx.isolates(g)))
    # 获得图中非连通点的列表 = []
    g.add_node(8)
    print("获得图中非连通点的列表=", list(nx.isolates(g)))
    # 获得图中非连通点的列表= [8]

    # 遍历
    d_gen = nx.dfs_edges(g, 1)  # 按边深度搜索, 1为起点
    b_gen = nx.bfs_edges(g, 1)
    print("深度搜索:",list(d_gen))
    # [(1, 2), (2, 3), (3, 6), (6, 5), (5, 4), (6, 7)]
    print("广度搜索:",list(b_gen))
    # [(1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (6, 7)]
    print(nx.dfs_tree(g, 1).nodes())  # 按点深搜g
    # [1, 2, 3, 6, 5, 4, 7]
    print("先序遍历:", list(nx.dfs_preorder_nodes(g, 1)))
    # 先序遍历: [1, 2, 3, 6, 5, 4, 7]
    print("后序遍历:", list(nx.dfs_postorder_nodes(g, 1)))
    # 后序遍历: [4, 5, 7, 6, 3, 2, 1]
    print("节点1和节点2的共同邻居：", list(nx.common_neighbors(g, 1, 2)))
    # 节点0和节点33的共同邻居： [3, 4, 6]
    print("节点1和节点7的共同邻居：", list(nx.common_neighbors(g, 1, 7)))
    # 节点0和节点33的共同邻居： [6]

结果如下：


所有节点之间的最短路径= {1: {1: [1], 2: [1, 2], 3: [1, 3], 4: [1, 4], 5: [1, 5], 6: [1, 6], 7: [1, 6, 7]}, 2: {2: [2], 1: [2, 1], 3: [2, 3], 4: [2, 4], 6: [2, 6], 5: [2, 1, 5], 7: [2, 6, 7]}, 3: {3: [3], 1: [3, 1], 2: [3, 2], 6: [3, 6], 4: [3, 1, 4], 5: [3, 1, 5], 7: [3, 6, 7]}, 4: {4: [4], 1: [4, 1], 2: [4, 2], 5: [4, 5], 3: [4, 1, 3], 6: [4, 1, 6], 7: [4, 1, 6, 7]}, 5: {5: [5], 1: [5, 1], 4: [5, 4], 6: [5, 6], 2: [5, 1, 2], 3: [5, 1, 3], 7: [5, 6, 7]}, 6: {6: [6], 1: [6, 1], 2: [6, 2], 3: [6, 3], 5: [6, 5], 7: [6, 7], 4: [6, 1, 4]}, 7: {7: [7], 6: [7, 6], 1: [7, 6, 1], 2: [7, 6, 2], 3: [7, 6, 3], 5: [7, 6, 5], 4: [7, 6, 1, 4]}}
各点之间可达性= {1: {1: 11.66037697759954, 2: 9.730688193140374, 3: 8.180239781697592, 4: 7.645194148638486, 5: 7.720951055876168, 6: 10.188202427433492, 7: 2.4556767248680185}, 2: {1: 9.730688193140374, 2: 8.966431076518731, 3: 7.2767859598006615, 4: 6.497877866101427, 5: 6.132652147982442, 6: 8.800266284965774, 7: 2.136327166832645}, 3: {1: 8.180239781697592, 2: 7.2767859598006615, 3: 6.750798019391801, 4: 4.922928096425332, 5: 4.985335865445396, 6: 7.643419657110174, 7: 1.9072819535912968}, 4: {1: 7.645194148638486, 2: 6.497877866101427, 3: 4.922928096425332, 4: 5.962359580374006, 5: 5.4295610915115375, 6: 6.2992895922037295, 7: 1.3858918410969554}, 5: {1: 7.720951055876168, 2: 6.132652147982442, 3: 4.985335865445396, 4: 5.4295610915115375, 5: 6.053240117357615, 6: 6.892984331374484, 7: 1.7072857005030746}, 6: {1: 10.188202427433492, 2: 8.800266284965774, 3: 7.643419657110174, 4: 6.2992895922037295, 5: 6.892984331374484, 6: 10.11197286752748, 7: 3.0514157654095175}, 7: {1: 2.4556767248680185, 2: 2.136327166832645, 3: 1.9072819535912968, 4: 1.3858918410969554, 5: 1.7072857005030746, 6: 3.0514157654095175, 7: 1.9054013217324557}}
获得图中非连通点的列表= []
获得图中非连通点的列表= [8]
深度搜索: [(1, 2), (2, 3), (3, 6), (6, 5), (5, 4), (6, 7)]
广度搜索: [(1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (6, 7)]
[1, 2, 3, 6, 5, 4, 7]
先序遍历: [1, 2, 3, 6, 5, 4, 7]
后序遍历: [4, 5, 7, 6, 3, 2, 1]
节点1和节点2的共同邻居： [3, 4, 6]
节点1和节点7的共同邻居： [6]
python与大数据分析
关注
Python 知识架构图
11-09
可以说是非常清晰的知识架构了，给想学python的朋友们，一个明确的学习方向。
Python 知识结构图
weixin_42552374的博客
11-08 1216
分享几个Python的网址，大家一起进步！ Python的知识结构图：http://lib.csdn.net/base/python/structure 生成器、lamda表达式及map、reduce、filter函数http://lib.csdn.net/article/python/1297 装饰器：http://lib.csdn.net/article/python...
python数据结构-图
漫漫行程路
02-14 658
图 图是一种数据间具有多对多关系的非线性数据结构 顶点的度：指与该顶点关联的边的数目 全部顶点的度之和为边数的两倍 图的存储有邻接矩阵，邻接表，十字链表 邻接矩阵 边采用顺序存储结构，用二维数组存储 邻接表 采用链式存储结构，存储行的后继，即矩阵行的单链表 十字链表 图的邻接多重表：采用链式存储结构，存放行和列的后继 图的广度优先算法 从某一个顶点开始，一次性访问他的邻接点，直到访问结束 利用栈实现 从源节点开始把节点按照深度放入栈，然后弹出 每弹出一个点，把该节点下一个没有进过栈的邻接点放入栈 直到栈变
python数据结构--图的简介
m0_46377561的博客
08-06 253
脱了很久的python数据结构终于学到了图这个部分，这个部分我的学习素材依旧是b站的视频，链接如下https://www.bilibili.com/video/BV1VC4y1x7uv?p=74。关于图的每一个小视频的知识我都会整理，要加油呀~ 这里写目录标题图的定义图的相关术语顶点、边权重路径圈 图的定义 图的相关术语 顶点、边 权重 路径 圈 ...
python实现图的结构
qq_41816189的博客
02-05 2281
节点定义 # 图节点结构 class Node: def __init__(self, value): self.value = value # 节点值 self.come = 0 # 入度 self.out = 0 # 出度 self.nexts = [] # 邻居节点 self.edges = [] # 在节点为from的情况下，边的集合 边定义 class Edges: def __init__(self, weight, fro
python数据结构之图深度优先和广度优先实例详解
12-24
本文实例讲述了python数据结构之图深度优先和广度优先用法。分享给大家供大家参考。具体如下： 首先有一个概念：回溯 　回溯法(探索与回溯法)是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时...
python数据结构之图的实现方法
01-20
本文实例讲述了python数据结构之图的实现方法。分享给大家供大家参考。具体如下： 下面简要的介绍下： 比如有这么一张图：  A -> B  A -> C  B -> C  B -> D  C -> D  D -> C  E -> F  F -> C 可以用字典和...
python基础编程：python数据结构之图深度优先和广度优先实例详解
01-20
本文实例讲述了python数据结构之图深度优先和广度优先用法。分享给大家供大家参考。具体如下： 首先有一个概念：回溯 回溯法(探索与回溯法)是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，...
Python数据结构之图的应用示例
01-20
本文实例讲述了Python数据结构之图的应用。分享给大家供大家参考，具体如下： 一、图的结构 二、代码 # -*- coding:utf-8 -*- #! python3 def searchGraph(graph,start,end): results =[] generatePath(graph,...
数据结构python数据结构练习题目与源代码
最新发布
06-05
3. python数据结构 4. python三大结构 5. 函数 第二部分--线性数据结构 1. 线性表 第三部分--非线性数据结构 1. 树和二叉树 2. 图 第四部分--数据结构操作 1. 查找 2. 排序 例如： 第七章 哈夫曼编码 # 树节点类...
Python数据结构与算法之图结构（Graph）实例分析
09-21
主要介绍了Python数据结构与算法之图结构（Graph）,结合实例形式分析了图结构的概念、原理、使用方法及相关操作技巧,需要的朋友可以参考下
图的结构 Python实现
weixin_34268843的博客
06-07 198
1.每个节点类型设置 1 # 图的节点结构 2 class Node: 3 def __init__(self, value): 4 self.value = value # 节点值 5 self.come = 0 # 节点入度 6 self.out = 0 # 节点出度 ...
图的结构 Python实现
xirongxu_dlut的博客
08-27 467
1.每个节点类型设置 1 # 图的节点结构 2 class Node: 3 def __init__(self, value): 4 self.value = value # 节点值 5 self.come = 0 # 节点入度 6 self.out = 0 # 节点出度 7 ...
图结构的python实现
moyao_miao的博客
04-01 323
【代码】图结构的python实现。
【实战案例】五分钟！用python绘制系统架构图
04-23 1089
Diagrams 是一个基于Python绘制云系统架构的模块，它能够通过非常简单的描述就能可视化架构，并支持以下6个云产品的图标： AWS、Azure、GCP、K8s、阿里云 和 Oracle 云 基于Diagrams提供的节点，你只需要指定一个云产品（实际上选哪个都一样，我们只需要那个产品相应的图标，你可以选一个自己觉得好看的产品），使用其内部自带的云产品的图标，就能简单绘制基于某云产品图标的...
Python数据结构——图形结构
m0_51894865的博客
02-08 1597
Python数据结构——图形结构 图：一种多对多的非线形数据结构； 图的应用：网络规划，地图规划； 图的遍历：广度优先 (BFS) 、深度优先 (DFS)； 图的类别：无向图 (GRAPH) 、有向图 (DIGRAPH)； 有向图：有向完全图，边长 n*(n-1) 个边； 强连通分支：最大的相互连通分支； 包含初度和入度； <1,2> 无向图：无向图，边长 n*(n-1)/2 个边； 连通分支：最大的相互连通分支； (1,2) 图的存储方式：是一个对称矩阵，保存下三角或上三角矩阵即可； 领结矩
Python 数据结构 —— 图
我有两颗糖
07-06 3277
1. 图的存储方式 1.1 图的存储数据结构 图可以用 邻接矩阵 和 邻接表 （Adjacency List）来表示，当边数不多的时候，使用邻接表存储效率更高 如存储下面的图： 对应的邻接表为： 1.2 字典实现邻接表 采用字典实现邻接表很方便： 2 顶点 Vertex 每一个顶点中存储了 顶点信息 + 相邻顶点信息，具有 addNeighbor(), getId(), getWeright() 等方法： class Vertex: def __init__(self, id): self.i
Python 中的图：图的存储结构
weixin_53598445的博客
04-15 5349
文章目录1 什么是图2 图的三种存储方式2.1 边列表(List of Edges)2.1.1 原理2.1.2 Python 实现 1 什么是图   图是一种数据结构，可用于对对象之间的层次结构和关系进行建模。它由一组节点和一组边组成。节点表示单个对象，而边表示这些对象之间的关系。注意：可能在不同的文献中节点也被称作顶点，它们指同一个意思。   如果图中的边可以通过双向遍历，则是无向图(undirected)，如果只能通过一个方向进行遍历，则是有向图(undirected)。 并非图的所有节点都需要与其他
Python数据结构与算法实战
"Python数据结构与算法，北京大学某学院课程，涵盖了Python编程、数据结构和算法的详细讲解，包括算法分析、基本数据结构类型、递归等核心概念。" 本资源详细介绍了Python语言在数据结构与算法领域的应用，旨在帮助...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

python与大数据分析

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值