精华内容
下载资源
问答
  • 主要介绍了python使用邻接矩阵构造图代码示例,具有一定参考价值,需要的朋友可以了解下。
  • I would like to create a large, weighted adjacency matrix from an image (so lots of vertices...... 10^5 vertices) in python. Weights between adjacent pixels are color gradients (I ta...

    I would like to create a large, weighted adjacency matrix from an image (so lots of vertices... in the order of > 10^5 vertices) in python. Weights between adjacent pixels are color gradients (I take care of this). Doing it by iterating through pixels is very slow... it takes over 4 minutes. :-( Are there any libraries that can do this nicely in reasonable time?

    The following is my code which runs very slowly:

    def indToCoord(ind, w, h):

    x = ind % w

    y = (ind - x)/h

    return (x,y)

    def isAdj(p1, p2, im):

    adj = []

    w, h = im.size

    x1, y1 = p1

    x2, y2 = p2

    if (x1, y1) == (x2, y2):

    return 0

    elif abs(x1 - x2) > 1:

    return 0

    elif abs(y1 - y2) > 1:

    return 0

    elif abs(x1 - x2) + abs(y1 - y2) >= 2:

    return 0

    return util.colorGradient(im, p1, p2)

    def adjForPixel(pixels, p1, im):

    return [isAdj(p1,p2,im) for p2 in pixels]

    # The following is the function I use to create an Adjacency Matrix from an image

    def getAdjMatrix(im):

    width, height = im.size

    pixels = [(x,y) for x in xrange(width) for y in xrange(height)]

    pixelAdjMatr = [adjForPixel(pixels, p, im) for p in pixels]

    return pixelAdjMatr

    adj_matrix = getAdjMatrix(im)

    Thank you!

    解决方案

    Python module/library NetworkX has an adjacency matrix implementation. It returns a scipy matrix

    import networkx as nx

    import scipy as sp

    g = nx.Graph([(1,1)])

    a = nx.adjacency_matrix(g)

    print a, type(a)

    returns

    (0, 0) 1

    展开全文
  • 利用python载入邻接矩阵绘制网络图,基于python语言的特点,对邻接矩阵加以处理后再进行应用,即将邻接矩阵去除第一列(节点序号列),复杂网络的基本拓扑结构可以用图论的方法表示成G =(V,E),V中元素称为节点或...
  • python邻接矩阵输出成图

    万次阅读 多人点赞 2018-03-21 20:28:35
    利用networkx,numpy,matplotlib,将邻接矩阵输出为图形。 1,自身确定一个邻接矩阵,然后通过循环的方式添加变,然后输出图像 import networkx as nx import matplotlib.pyplot as plt import numpy as np G ...

    利用networkx,numpy,matplotlib,将邻接矩阵输出为图形。

    1,自身确定一个邻接矩阵,然后通过循环的方式添加变,然后输出图像

    import networkx as nx
    import matplotlib.pyplot as plt
    import numpy as np
    
    G = nx.Graph()
    Matrix = np.array(
        [
            [0, 1, 1, 1, 1, 1, 0, 0],  # a
            [0, 0, 1, 0, 1, 0, 0, 0],  # b
            [0, 0, 0, 1, 0, 0, 0, 0],  # c
            [0, 0, 0, 0, 1, 0, 0, 0],  # d
            [0, 0, 0, 0, 0, 1, 0, 0],  # e
            [0, 0, 1, 0, 0, 0, 1, 1],  # f
            [0, 0, 0, 0, 0, 1, 0, 1],  # g
            [0, 0, 0, 0, 0, 1, 1, 0]  # h
        ]
    )
    for i in range(len(Matrix)):
        for j in range(len(Matrix)):
            G.add_edge(i, j)
    
    nx.draw(G)
    plt.show()
    
    

    2,有向图

    G = nx.DiGraph()
    G.add_node(1)
    G.add_node(2)
    G.add_nodes_from([3, 4, 5, 6])
    G.add_cycle([1, 2, 3, 4])
    G.add_edge(1, 3)
    G.add_edges_from([(3, 5), (3, 6), (6, 7)])
    nx.draw(G)
    # plt.savefig("youxiangtu.png")
    plt.show()
    

    3,   5节点完全图

    G = nx.complete_graph(5)
    nx.draw(G)
    plt.savefig("8nodes.png")
    plt.show()

    4,无向图

    G = nx.Graph()
    G.add_node(1)
    G.add_node(2)
    G.add_nodes_from([3, 4, 5, 6])
    G.add_cycle([1, 2, 3, 4])
    G.add_edge(1, 3)
    G.add_edges_from([(3, 5), (3, 6), (6, 7)])
    nx.draw(G)
    # plt.savefig("wuxiangtu.png")
    plt.show()
    

    5,颜色节点图

    G = nx.Graph()
    G.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (4, 5), (4, 6), (5, 6)])
    pos = nx.spring_layout(G)
    
    colors = [1, 2, 3, 4, 5, 6]
    nx.draw_networkx_nodes(G, pos, node_color=colors)
    nx.draw_networkx_edges(G, pos)
    
    plt.axis('off')
    # plt.savefig("color_nodes.png")
    plt.show()
    


    将图转化为邻接矩阵,再将邻接矩阵转化为图,还有图的集合表示,邻接矩阵表示,图形表示,这三种表现形式互相转化的问题是一个值得学习的地方,继续加油!

    展开全文
  • 一个生成邻接矩阵的小函数,辅助我上传的一个资源的子函数
  • python制作DAG图,生成邻接矩阵

    千次阅读 2019-03-08 19:44:06
    主要方法是运用Top排序倒退回来,这里我考虑到节点和和边内容的一些关系,假设有n个节点,这里控制边的个数为[n-1,(n*(n-1)/2+1] from random import randint as rd import numpy as np def DataMake(): ...

    主要方法是运用Top排序倒退回来,这里我考虑到节点和和边内容的一些关系,假设有n个节点,这里控制边的个数为[n-1,(n*(n-1)/2+1]

    from random import randint as rd
    import numpy as np
    def DataMake():
        n=int(input("请输入设置的节点数:"))
        node=range(1,n+1)
        node=list(node)
        m=rd(n-1,(n*(n-1))/2+1)
        DAG=np.zeros((n,n))
        for i in range(0,m):
            p1=rd(1,n-1)
            p2=rd(p1+1,n)
            x=node[p1-1]
            y=node[p2-1]
            l=np.random.randint(10,20)
            if DAG[x-1][y-1]!=0:
                continue
            else:
                DAG[x-1][y-1]=l
        print(DAG)
        np.savetxt("DAG.txt",DAG,fmt='%.2f')
    DataMake()
    
    展开全文
  • 邻接清单 该无向循环图可以由三个无序列表{b,c},{a,c},{a,b}来描述。 在图论和计算机科学中,邻接列表是用于表示有限图的无序列表的集合。每个列表描述图中顶点的邻居集。这是用于计算机程序的几种常用图形...

    邻接清单

     

    该无向循环图可以由三个无序列表{b,c },{a,c },{a,b }来描述。

    图论计算机科学中邻接列表是用于表示有限的无序列表的集合。每个列表描述图中顶点的邻居集。这是用于计算机程序的几种常用图形表示之一。

    内容

    实施细节

    上图所示的图表具有以下邻接列表表示:
    一种 毗邻 公元前
    b 毗邻 A,C
    C 毗邻 A,B

    图的邻接列表表示将图中的每个顶点与其相邻顶点或边的集合相关联。这个基本思想有很多变化,它们如何实现顶点和集合之间的关联,它们如何实现集合的细节不同,它们是包括顶点和边缘还是仅包括顶点作为第一类对象,以及各种对象用于表示顶点和边。

    • Guido van Rossum建议的实现使用哈希表将图中的每个顶点与相邻顶点的数组相关联。在该表示中,顶点可以由任何可清洗对象表示。边缘没有明确表示为对象。[1]
    • Cormen等。提出了一个实现,其中顶点由索引号表示。[2]它们的表示使用由顶点编号索引的数组,其中每个顶点的数组单元指向该顶点的相邻顶点的单链表。在该表示中,单链表的节点可以被解释为边缘对象; 但是,它们不存储关于每条边的完整信息(它们只存储边缘的两个端点之一),而在无向图中,每条边将有两个不同的链表节点(两个边中的每一个都有一个)边缘的端点)。
    • 面向对象的,由Goodrich和Tamassia建议发病列表结构具有顶点对象和边缘对象的特殊类。每个顶点对象都有一个实例变量,指向一个列出相邻边缘对象的集合对象。反过来,每个边缘对象指向其端点处的两个顶点对象。[3]此版本的邻接列表使用的内存多于直接列出相邻顶点的版本,但显式边缘对象的存在使其在存储有关边的附加信息时具有额外的灵活性。

    操作

    邻接列表数据结构执行的主要操作是报告给定顶点的邻居列表。使用上面详述的任何实现,这可以在每个邻居的恒定时间内执行。换句话说,总时间报告所有顶点的邻居v成正比程度v

    使用邻接列表来测试两个指定顶点之间是否存在边缘也是可能的,但效率不高。在其中每个顶点的邻居未被排序的邻接列表中,通过使用通过该顶点的邻居的顺序搜索,可以在与两个给定顶点的最小程度成比例的时间内执行对边缘的存在的测试。如果邻居被表示为排序数组,则可以使用二进制搜索,花费与度数的对数成比例的时间。

    权衡

    邻接列表的主要替代是邻接矩阵矩阵的行和列由顶点索引,并且其单元格包含布尔值,该布尔值指示在对应于单元格的行和列的顶点之间是否存在边缘。对于稀疏图(其中大多数顶点对不通过边连接)邻接列表比邻接矩阵(存储为数组)明显更节省空间:邻接列表的空间使用与边和顶点的数量成比例在图中,对于以这种方式存储的邻接矩阵,空间与顶点数的平方成比例。然而,通过使用由顶点对而不是数组索引的散列表,可以更节省空间地存储邻接矩阵,匹配邻接列表的线性空间使用。

    邻接列表和邻接矩阵之间的另一个显着差异在于它们执行的操作的效率。在邻接列表中,可以有效地列出每个顶点的邻居,其时间与顶点的程度成比例。在邻接矩阵中,该操作花费与图中顶点数量成比例的时间,其可能明显高于度数。另一方面,邻接矩阵允许测试两个顶点是否在恒定时间内彼此相邻; 邻接列表较慢以支持此操作。

    数据结构

    为了用作数据结构,邻接列表的主要替代是邻接矩阵。因为邻接矩阵中的每个条目只需要一个位,所以它可以以非常紧凑的方式表示,仅占用| V | 2 /8个字节的连续空间,其中| V | 是图的顶点数。除了避免浪费的空间,这种紧凑性鼓励参考的地方。

    但是,对于稀疏图,邻接列表需要较少的空间,因为它们不会浪费任何空间来表示不存在的边。在32位计算机上使用简单的数组实现,无向图的邻接列表需要大约2·(32/8)| E | = 8 | E | 空格的字节,其中| E | 是图的边数。

    注意到无向简单图可以具有至多(| V | 2 - | V |)/ 2≈ 2层的边缘,从而允许环,就能够让d = | E | / | V | 2表示图的密度。然后,8 | E | > | V | 2 /8时| E | / | V | 2 > 1/64,即当d > 1/64时,邻接列表表示占用比邻接矩阵表示更多的空间。因此,图形必须足够稀疏以证明邻接列表表示。

    除了空间权衡之外,不同的数据结构也有助于不同的操作。在邻接列表中查找与给定顶点相邻的所有顶点就像读取列表一样简单。使用邻接矩阵,必须扫描整行,这需要O(| V |)时间。在两个给定顶点之间是否存在边缘可以用邻接矩阵一次确定,同时需要与具有邻接列表的两个顶点的最小程度成比例的时间。

    参考

    1. Guido van Rossum(1998)。“Python模式 - 实现图形”
    2. Thomas H. CormenCharles E. LeisersonRonald L. RivestClifford Stein(2001)。算法导论,第二版。麻省理工学院出版社和McGraw-Hill。第22.1节第527-529页:图表的表示。国际标准书号  0-262-03293-7
    3. Michael T. GoodrichRoberto Tamassia(2002)。算法设计:基础,分析和Internet示例。John Wiley&Sons。国际标准书号  0-471-38365-1
    import networkx as nx
    import matplotlib.pyplot as plt
    #图类
    class Graph_Matrix:
        """
        Adjacency Matrix
        """
        def __init__(self, vertices=[], matrix=[]):
            """
    
            :param vertices:a dict with vertex id and index of matrix , such as {vertex:index}
            :param matrix: a matrix
            """
            self.matrix = matrix
            self.edges_dict = {}  # {(tail, head):weight}
            self.edges_array = []  # (tail, head, weight)
            self.vertices = vertices
            self.num_edges = 0
    
            # if provide adjacency matrix then create the edges list
            if len(matrix) > 0:
                if len(vertices) != len(matrix):
                    raise IndexError
                self.edges = self.getAllEdges()
                self.num_edges = len(self.edges)
    
            # if do not provide a adjacency matrix, but provide the vertices list, build a matrix with 0
            elif len(vertices) > 0:
                self.matrix = [[0 for col in range(len(vertices))] for row in range(len(vertices))]
    
            self.num_vertices = len(self.matrix)
    
        def isOutRange(self, x):
            try:
                if x >= self.num_vertices or x <= 0:
                    raise IndexError
            except IndexError:
                print("节点下标出界")
    
        def isEmpty(self):
            if self.num_vertices == 0:
                self.num_vertices = len(self.matrix)
            return self.num_vertices == 0
    
        def add_vertex(self, key):
            if key not in self.vertices:
                self.vertices[key] = len(self.vertices) + 1
    
            # add a vertex mean add a row and a column
            # add a column for every row
            for i in range(self.getVerticesNumbers()):
                self.matrix[i].append(0)
    
            self.num_vertices += 1
    
            nRow = [0] * self.num_vertices
            self.matrix.append(nRow)
    
        def getVertex(self, key):
            pass
    
        def add_edges_from_list(self, edges_list):  # edges_list : [(tail, head, weight),()]
            for i in range(len(edges_list)):
                self.add_edge(edges_list[i][0], edges_list[i][1], edges_list[i][2], )
    
        def add_edge(self, tail, head, cost=0):
            # if self.vertices.index(tail) >= 0:
            #   self.addVertex(tail)
            if tail not in self.vertices:
                self.add_vertex(tail)
            # if self.vertices.index(head) >= 0:
            #   self.addVertex(head)
            if head not in self.vertices:
                self.add_vertex(head)
    
            # for directory matrix
            self.matrix[self.vertices.index(tail)][self.vertices.index(head)] = cost
            # for non-directory matrix
            # self.matrix[self.vertices.index(fromV)][self.vertices.index(toV)] = \
            #   self.matrix[self.vertices.index(toV)][self.vertices.index(fromV)] = cost
    
            self.edges_dict[(tail, head)] = cost
            self.edges_array.append((tail, head, cost))
            self.num_edges = len(self.edges_dict)
    
        def getEdges(self, V):
            pass
    
        def getVerticesNumbers(self):
            if self.num_vertices == 0:
                self.num_vertices = len(self.matrix)
            return self.num_vertices
    
        def getAllVertices(self):
            return self.vertices
    
        def getAllEdges(self):
            for i in range(len(self.matrix)):
                for j in range(len(self.matrix)):
                    if 0 < self.matrix[i][j] < float('inf'):
                        self.edges_dict[self.vertices[i], self.vertices[j]] = self.matrix[i][j]
                        self.edges_array.append([self.vertices[i], self.vertices[j], self.matrix[i][j]])
    
            return self.edges_array
    
        def __repr__(self):
            return str(''.join(str(i) for i in self.matrix))
    
        def to_do_vertex(self, i):
            print('vertex: %s' % (self.vertices[i]))
    
        def to_do_edge(self, w, k):
            print('edge tail: %s, edge head: %s, weight: %s' % (self.vertices[w], self.vertices[k], str(self.matrix[w][k])))
    #第一种方法,二维数组生成图
    def create_undirected_matrix(my_graph):
        nodes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
    
        matrix = [[0, 1, 1, 1, 1, 1, 0, 0],  # a
                  [0, 0, 1, 0, 1, 0, 0, 0],  # b
                  [0, 0, 0, 1, 0, 0, 0, 0],  # c
                  [0, 0, 0, 0, 1, 0, 0, 0],  # d
                  [0, 0, 0, 0, 0, 1, 0, 0],  # e
                  [0, 0, 1, 0, 0, 0, 1, 1],  # f
                  [0, 0, 0, 0, 0, 1, 0, 1],  # g
                  [0, 0, 0, 0, 0, 1, 1, 0]]  # h
    
        my_graph = Graph_Matrix(nodes, matrix)
        print(my_graph)
        return my_graph
    #第二种方法,二维数组生成有向图
    def create_directed_matrix(my_graph):
        nodes = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
        inf = float('inf')
        matrix = [[0, 2, 1, 3, 9, 4, inf, inf],  # a
                  [inf, 0, 4, inf, 3, inf, inf, inf],  # b
                  [inf, inf, 0, 8, inf, inf, inf, inf],  # c
                  [inf, inf, inf, 0, 7, inf, inf, inf],  # d
                  [inf, inf, inf, inf, 0, 5, inf, inf],  # e
                  [inf, inf, 2, inf, inf, 0, 2, 2],  # f
                  [inf, inf, inf, inf, inf, 1, 0, 6],  # g
                  [inf, inf, inf, inf, inf, 9, 8, 0]]  # h
    
        my_graph = Graph_Matrix(nodes, matrix)
        print(my_graph)
    #第三种方法,用边生成有向图
    def create_directed_graph_from_edges(my_graph):
        nodes = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
        edge_list = [('A', 'F', 9), ('A', 'B', 10), ('A', 'G', 15), ('B', 'F', 2),
                     ('G', 'F', 3), ('G', 'E', 12), ('G', 'C', 10), ('C', 'E', 1),
                     ('E', 'D', 7)]
    
        my_graph = Graph_Matrix(nodes)
        my_graph.add_edges_from_list(edge_list)
        print(my_graph)
    #1.显示无向图
    def draw_undircted_graph(my_graph):
        G = nx.Graph()  # 建立一个空的无向图G
        for node in my_graph.vertices:
            G.add_node(str(node))
        for edge in my_graph.edges:
            G.add_edge(str(edge[0]), str(edge[1]))
    
        print("nodes:", G.nodes())  # 输出全部的节点: [1, 2, 3]
        print("edges:", G.edges())  # 输出全部的边:[(2, 3)]
        print("number of edges:", G.number_of_edges())  # 输出边的数量:1
        nx.draw(G, with_labels=True)
        plt.savefig("undirected_graph.png")
        plt.show()
    
        return my_graph
        return my_graph
    #2.显示有向图,带权
    
    def draw_directed_graph(my_graph):
        G = nx.DiGraph()  # 建立一个空的无向图G
        for node in my_graph.vertices:
            G.add_node(str(node))
        G.add_weighted_edges_from(my_graph.edges_array)
    
        print("nodes:", G.nodes())  # 输出全部的节点
        print("edges:", G.edges())  # 输出全部的边
        print("number of edges:", G.number_of_edges())  # 输出边的数量
        nx.draw(G, with_labels=True)
        plt.savefig("directed_graph.png")
        plt.show()
    

    特别鸣谢:https://blog.csdn.net/fly_hawk/article/details/78513257

    展开全文
  • ------------------在python中导出矩阵至matlab------------------------------ 一、通过文本文件 如果矩阵是mxn维的。 那么可以用 : np.savetxt('dev_ivector.csv', dev_ivector, delimiter = ',') 对应matlab...
  • 简单地说,使用networkx作图,然后...从邻接矩阵生成networkx中graph类,使用from_numpy_matrix函数,详见:https://networkx.github.io/documentation/networkx-1.7/reference/generated/networkx.convert.from_nu...
  • 但是ucinet这个社会网络分析工具只接受矩阵格式的数据,本白嫖大王于是在CSDN、知乎、各种问答网站上一通搜索提问邀请三连,最终啥也没搜到,只好自己动手丰衣足食。在自己提的知乎问题下面回复已解决后出乎意料竟然...
  • 2.使用arcgis生成质心坐标(1)打开shp地图的属性(2)按照相同的方法生成Y(3)属性表转化成Excel表(4)如下根据需要进行更改其中:pgdp是2006-2018年的平均GDP,X经度,Y纬度2Stata生成空间权重矩阵1.构造0-1矩阵关于0-1...
  • [python]邻接表转邻接矩阵

    千次阅读 2019-04-08 00:39:06
    这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、...
  • python生成小世界网络并输出邻接矩阵
  • 使用从数据库中导出的论文、专利数据,做作者/专利...生成合作网络代码主函数: if __name__ =='__main__' : co_list = [ ["AA | BB | CC | DD",2019], ["EE | BB | FF ",2018], ["AA | GG | FF | HH | KK",2019],
  • Matlab如何将无向图生成邻接矩阵?图是gml格式的,图是gml的数据,很多点,每个点有id,边和value
  • edges = [ 1 2; 1 3; 1 4; 2 3; 3 4]; G = graph(edges(:,1),edges(:,2)); adjMatrix = full(adjacency(G)); % adjacency(G)返回邻接矩阵的稀疏矩阵

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,879
精华内容 751
关键字:

python生成邻接矩阵

python 订阅