精华内容
下载资源
问答
  • 会根据根据图画出邻接表、邻接矩阵存储,反之要会还原出 关注以下例子:

    会根据根据图画出邻接表、邻接矩阵存储,反之要会还原出图

    关注以下例子:

     

    展开全文
  • 图的邻接矩阵算法

    2021-05-15 08:12:13
    无向图的邻接矩阵关于左上右下对角线对称的,有向图不一定对称 先得理解矩阵描述的图,或者明白图的矩阵描述概念。 图的邻接矩阵存储结构 #define MAX 100 typedef struct{ char vexs[MAX]; //顶点表 int arc...
    • 无向图的邻接矩阵是关于左上右下对角线对称的,有向图不一定对称
    • 先得理解矩阵描述的图,或者明白图的矩阵描述概念。

    图的邻接矩阵存储结构

    #define MAX 100
    typedef struct{
    	char vexs[MAX]; //顶点表
    	int arc[MAX][MAX];//邻接矩阵,也就是边的关系表
    	int numVertexes,numEdges;//图中的定点数和边数 
    }MGaph;
    

    根据邻接矩阵的定义,可得到建立图的邻接矩阵算法。

    • 算法描述:首先得到图的顶点数和边数、然后按照顶点的数量后再将顶点的名称逐一放入字符存储数组当中、再把关系矩阵全部初始化置零、知道边数,利用一个循环把每两条边的关系描述出来。
    /*建立无向图邻接矩阵*/
    void GreatMGaph(MGaph *G){
    	int i,j,k;
    	char ch1,ch2;
    	printf("请输入顶点数和边数:");
    	scanf("%d%d",&G->numEdges,&G->numVertexes);
    	getchar();
    	printf("顶点边数输入成功!\n");
    	
    	/*输入顶点信息(名称)*/
    	for(i=0;i<G->numEdges;i++){
    		printf("请输入第%d个顶点name:",i+1);
    		scanf("%c",&(G->vexs[i]));
    		getchar();
    	} 
    	/*建立顶点之间的联系*/
    	//置零
     	for(i=0;i<G->numEdges;i++){
    		for(j=0;j<G->numEdges;j++){
    			G->arc[i][j] = 0;
    		}
    	}
    	//输入关系
    	for(k=0;k<G->numVertexes;k++){
    		printf("建立第%d条边:",k+1);
    		scanf("%c,%c",&ch1,&ch2);
    		getchar(); 
    		for(i=0;i<G->numEdges;i++){
    			for(j=0;j<G->numEdges;j++){
    				if(ch1 == G->vexs[i] && ch2 == G->vexs[j]){
    					G->arc[i][j] = 1;//可以在此处修改为带权的图 
    					G->arc[j][i] = 1;//无向图对称,该语句作用 
    				}
    			}
    		}
    	} 
    }
    

    最后还得输出这个邻接矩阵

    void DisPlay(MGaph *G){
    	int i,j;
    	for(i=0;i<G->numEdges;i++){
    		for(j=0;j<G->numEdges;j++){
    			printf("%d ",G->arc[i][j]);
    		}
    		printf("\n");
    	}
    	
    }
    

    当然要实现整个矩阵的建立及输出还要编写主函数

    int main() {
    	MGaph G;//图G 
    	GreatMGaph(&G);
    	DisPlay(&G);
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 有向图的邻接矩阵

    2012-11-07 17:25:46
    关于有向图的邻接矩阵的实验报告有具体的实验步骤
  • -邻接矩阵

    2018-10-23 08:53:09
    这是一篇关于无向带权图的模板代码整理,用邻接矩阵表示图,实现图的深度优先遍历和广度优先遍历。 也可以改为有向带权图,需要在插入、删除函数作出相应的改变。 邻接矩阵表示图优缺点总结:稠密图用邻接矩阵。 ...

    这是一篇关于无向带权图的模板代码整理,用邻接矩阵表示图,实现图的深度优先遍历和广度优先遍历。

    也可以改为有向带权图,需要在插入、删除函数作出相应的改变。

    邻接矩阵表示图优缺点总结:稠密图用邻接矩阵。

    • 邻接矩阵把所有结点的信息都保留下来,信息保留全面,查询也方便;但,当图中结点的之间联系较少时,这时的邻接矩阵为稀疏矩阵,存储了大量的0或无穷值。信息价值密度低。只有稠密图对应的邻接矩阵才不是稀疏矩阵,因此,复杂的图用邻接矩阵表示为佳。

     

    //
    //  main.cpp
    //  图-邻接矩阵
    //
    //  Created by scnulpc on 2018/10/22.
    //  Copyright © 2018年 scnulpc. All rights reserved.
    //
    
    #include <iostream>
    #include <queue>
    #define maxWeight 99
    using namespace std;
    const int DefaultVertices = 30;
    
    template <class T,class E>
    class Graph     //带权无向图
    {
    private:
        T * VerticesList;   //顶点表
        E **Edge;           //邻接矩阵
        int maxVertices;    //图中最大顶点数
        int numEdges;       //当前边数
        int numVertices;    //当前顶点数
        
        
    public:
        Graph(int sz=DefaultVertices);
        ~Graph();
        int numberOfVertices(){return numVertices;}
        int numberOfEdge(){return numEdges;}
        int getVertexPosition(T v);         //获取顶点v的位置
        T getValue(int i);                  //取顶点i的值,i不合理返回0
        E getWeight(int v1,int v2);         //取边(v1,v2)边上的权值
        int getFirstNeighbor(int v);        //取顶点v的第一个邻接顶点
        int getNextNeighbor(int v,int w);   //取v的邻接顶点w的下一个邻接顶点
        bool insertVertex(const T& vertex); //插入顶点vertex
        bool insertEdge(int v1,int v2,E weight);//插入边
        bool removeVertex(int v);           //删除顶点v及其关联的边
        bool removeEdge(int v1,int v2);     //删除边(v1,v2)
        friend istream& operator>>(istream& in,Graph<T,E> &g);//重载输入
        friend ostream& operator<<(ostream& out,Graph<T,E> &g);//重载输出
        void input();   //测试输入
        void output();  //测试输出
        void outputAsMatrix();  //测试输出
    };
    
    template <class T,class E>
    Graph<T, E>::Graph(int sz)
    {
        VerticesList = new T[sz];
        maxVertices=sz;
        numVertices=0;
        numEdges=0;
        Edge = new E* [sz];
        for (int i=0; i<maxVertices; i++)
        {
            Edge[i] = new E[sz];
        }
        for (int i=0; i<maxVertices; i++)
        {
            for (int j=0; j<maxVertices; j++)
            {
                if (i==j) Edge[i][j]=0;
                else Edge[i][j] = maxWeight;
            }
        }
    }
    template <class T,class E>
    Graph<T, E>::~Graph<T, E>()
    {
        delete []VerticesList;
        delete []Edge;
    }
    template <class T,class E>
    int Graph<T,E>::getVertexPosition(T v)
    {
        for (int i=0; i<numVertices; i++) {
            if (VerticesList[i]==v)return i;
        }
        return -1;
    }
    template <class T,class E>
    T Graph<T,E>::getValue(int i)
    {
        return (i>=0&&i<numVertices)? VerticesList[i]:0;
    }
    template <class T,class E>
    E Graph<T,E>::getWeight(int v1, int v2)
    {
        return (v1!=-1&&v2!=-1)? Edge[v1][v2]:0;
    }
    template <class T,class E>
    int  Graph<T,E>::getFirstNeighbor(int v)
    {
        if (v!=-1) {
            for (int i=0; i<numVertices; i++) {
                if (Edge[v][i]>0&&Edge[v][i]<maxWeight) return i;
            }
        }
        return -1;
    }
    template <class T,class E>
    int  Graph<T,E>::getNextNeighbor(int v, int w)
    {
        if (v!=-1&&w!=-1) {
            for (int column = w+1; column<numVertices; column++) {
                if (Edge[v][column]>0&&Edge[v][column]<maxWeight) return column;
            }
        }
        return -1;
    }
    
    template <class T,class E>
    bool Graph<T,E>::insertVertex(const T &vertex)
    {
        if (numVertices==maxVertices) return false;
        VerticesList[numVertices++]=vertex;
        return true;
    }
    template <class T,class E>
    bool  Graph<T,E>::insertEdge(int v1, int v2, E weight)
    {
        if (v1!=-1&&v2!=-1) {
            Edge[v1][v2]=Edge[v2][v1]=weight;
            return true;
        }
        return false;
    }
    template <class T,class E>
    bool Graph<T,E>::removeVertex(int v)    //充分利用要被删除的那一行,那一列的空间,替换为最后一行,一列,numVertex--
    {
        if (v<0||v>=numVertices)return false;   //顶点不在图中
        if (numVertices==1) return false;       //只剩一个顶点,不删除
        VerticesList[v]=VerticesList[numVertices-1];//顶点表中删除该结点
        for (int i=0; i<numVertices; i++)
        {
            if (Edge[v][i]>0&&Edge[v][i]<maxWeight)
            {
                //Edge[v][i]=Edge[i][v]=maxWeight;
                numEdges--;
            }
        }
        for (int i=0; i<numVertices; i++)       //用最后一列填补第v列
        {
            Edge[i][v] = Edge[i][numVertices-1];
            Edge[i][numVertices-1] = maxWeight;
        }
        for (int i=0; i<numVertices; i++)       //用最后一行填补第v行
        {
            Edge[v][i]=Edge[numVertices-1][i];
            Edge[numVertices-1][i]=maxWeight;
        }
        Edge[numVertices-1][numVertices-1]=0;   //对角线为0
        numVertices--;                          //顶点数减一
        return true;
    }
    
    template <class T,class E>
    bool Graph<T,E>::removeEdge(int v1, int v2)
    {
        if (v1>-1&&v1<numVertices&&v2>-1&&v2<numVertices&&Edge[v1][v2]>0&&Edge[v1][v2]<maxWeight)
        {
            Edge[v1][v2]=Edge[v2][v1]=maxWeight;
            numEdges--;
            return true;
        }
        return false;
    }
    
    template <class T,class E>
    istream& operator>>(istream& in,Graph<T, E> &g)
    {
        int i,j,k,n,m;
        T e1,e2;
        E weight;
        cout<<"输入顶点数n和变数m"<<endl;
        in>>n>>m;
        cout<<"输入"<<n<<"个顶点的信息"<<endl;
        for (i=0; i<n; i++)
        {
            in>>e1;
            g.insertVertex(e1);
        }
        i=0;
        cout<<"输入"<<m<<"条边的信息\n端点e1 端点e2 权重"<<endl;
        while(i<m)
        {
            in>>e1>>e2>>weight;
            j=g.getVertexPosition(e1);
            k=g.getVertexPosition(e2);
            if (j==-1||k==-1) {
                cout<<"边两端信息有误,重新输入这条边"<<endl;
            }
            else
            {
                g.insertEdge(e1, e2, weight);
            }
        }
        return in;
    }
    template <class T,class E>
    ostream& operator<<(ostream& out,Graph<T, E> &g)
    {
        int i,j,n,m;T e1,e2;E w;
        n=g.numberOfVertices();
        m=g.numberOfEdge();
        out<<n<<","<<m<<endl;
        for (i=0; i<n; i++) {
            for (j=i+1; j<n; j++)
            {
                w=g.getWeight(i, j);
                if (w>0&&w<w<maxWeight) {
                    e1 = g.getValue(i);
                    e2 = g.getValue(j);
                    out<<"("<<e1<<","<<e2<<","<<w<<")"<<endl;
                }
            }
    
        }
        return out;
    }
    template <class T,class E>
    void Graph<T,E>::input()
    {
        int i,j,k,n,m;
        T e1,e2;
        E weight;
        cout<<"输入顶点数n和变数m"<<endl;
        cin>>n>>m;
        cout<<"输入"<<n<<"个顶点的信息"<<endl;
        for (i=0; i<n; i++)
        {
            cin>>e1;
            insertVertex(e1);
        }
        i=0;
        cout<<"输入"<<m<<"条边的信息\n端点e1 端点e2 权重"<<endl;
        while(i<m)
        {
            cin>>e1>>e2>>weight;
            j=getVertexPosition(e1);
            k=getVertexPosition(e2);
            if (j==-1||k==-1) {
                cout<<"边两端信息有误,重新输入这条边"<<endl;
            }
            else
            {
                insertEdge(j, k, weight);
                i++;
            }
        }
        
    }
    template <class T,class E>
    void Graph<T,E>::output()
    {
        int i,j,n,m;T e1,e2;E w;
        n=numberOfVertices();
        m=numberOfEdge();
        cout<<n<<","<<m<<endl;
        for (i=0; i<n; i++) {
            for (j=i+1; j<n; j++)
            {
                w=getWeight(i, j);
                if (w>0&&w<w<maxWeight) {
                    e1 = getValue(i);
                    e2 = getValue(j);
                    cout<<"("<<e1<<","<<e2<<","<<w<<")"<<endl;
                }
            }
            
        }
        
    }
    template <class T,class E>
    void Graph<T,E>::outputAsMatrix()
    {
        int i,j,n,m;T e1,e2;E w;
        n=numberOfVertices();
        m=numberOfEdge();
        cout<<n<<","<<m<<endl;
        cout<<"   ";
        for (int i=0; i<n; i++) {
            cout<<VerticesList[i]<<"  ";
        }
        cout<<endl;
        for (i=0; i<n; i++) {
            cout<<VerticesList[i]<<" ";
            for (j=0; j<n; j++)
            {
                w=getWeight(i, j);
                cout<<w<<" ";
            }
            cout<<endl;
        }
    }
    
    //邻接矩阵图的深度优先搜索
    template <class T,class E>
    void DFS(Graph<T,E> *G,const T v)
    {
        int n = G->numberOfVertices();
        bool *visit = new bool[n];
        for (int i=0; i<n; i++)visit[i]=false;
        int index = G->getVertexPosition(v);
        DFS(G, index, visit);
        delete []visit;
            
    }
    template <class T,class E>
    void DFS(Graph<T,E> *G,int v,bool visit[])
    {
        cout<<G->getValue(v)<<" ";
        visit[v]=1;
        int w = G->getFirstNeighbor(v);
        while (w!=-1)
        {
            if (visit[w]==false) DFS(G, w, visit);
            w=G->getNextNeighbor(v, w);
        }
    }
    
    //邻接矩阵图的广度遍历
    template <class T,class E>
    void BFS(Graph<T,E> *G,const T v)
    {
        int index = G->getVertexPosition(v);
        if (index==-1) return;
        queue<int > q ;
        q.push(index);
        int n = G->numberOfVertices();
        bool *visited = new bool[n];
        for (int i=0; i<n; i++)visited[i]=false;
        visited[index]=true;
        int temp;
        while (!q.empty())
        {
            temp = q.front();q.pop();
            cout<<G->getValue(temp)<<" ";
            
            int w = G->getFirstNeighbor(temp);
            while (w!=-1) {
                if (visited[w]==false) {q.push(w);visited[w]=true;}
                w = G->getNextNeighbor(temp, w);
            }
        }
        
    }
    /*测试数据 9 10 A B C D E F G H I
     A D 1
     A C 1
     A B 1
     B E 1
     B C 1
     E G 1
     D F 1
     C F 1
     F H 1
     H I 1
     */
    int main(int argc, const char * argv[])
    {
        Graph<char, int > *graph = new Graph<char, int>(20);
        graph->input();
        graph->output();
        graph->outputAsMatrix();
        DFS(graph, 'A');
        cout<<endl;
        cout<<"广度遍历"<<endl;
        BFS(graph, 'A');
        return 0;
    }
    

     

    展开全文
  • 睚雪:图(邻接矩阵)​zhuanlan.zhihu.com上面那个连接关于图的基础概念和DFS BFS都有介绍前文又介绍到邻接矩阵的缺点以及好处 为了解决他生成稀疏图浪费的缺点我们可以选择另一种实现方式 邻接矩阵实现方式上面的...
    睚雪:图(邻接矩阵)zhuanlan.zhihu.com
    zhihu-card-default.svg

    上面那个连接关于图的基础概念和DFS BFS都有介绍

    前文又介绍到邻接矩阵的缺点以及好处 为了解决他生成稀疏图浪费的缺点我们可以选择另一种实现方式 邻接矩阵

    实现方式

    1fbe677d3aae2bfca8ce9f43b45849f6.png

    上面的图片来自于https://blog.csdn.net/weixin_39469127/article/details/81082019

    如果这位作者不允许我使用的话可以联系我 我会撤掉

    邻接表是一个链表的集合,对于每一个节点V建立一个链表将每一个非零边存储在链表里 采用头插法

    特点:

    1. 对于系稀疏图比较划算,但是稠密图就浪费了
    2. 里面每一个节点占据两个空间都可能被存储多次
    3. 对于寻找邻接点也是很方便的,只需要沿着那个节点的链表遍历就可以了
    4. 方便计算无向图的度,但是对于有向图只能计算出度 计算入度需要一个逆邻接表
    5. 关于出入度 我想着可以在节点实现类里增加两个值分别代表出入度 就比较好计算了
    6. 正邻接表是将邻接矩阵的每一行存成链表 逆邻接表是将每一列存成链表

    代码结构

    public class Vertex { //顶点的结构
        public String verName;
        int inRadius,outRadius; //出入度
        public Vertex next; //下一个邻接点
    }
    public class Edge { //边的结构
        public Integer fromvex,endvex; //用来表示有向边<fromvex,endvex> 存的是顶点下标
        public Integer Weight; //权重
    }
    public class Graph { //图的结构
        public static int MaxSize = 200;
        public Vertex[] list = new Vertex[MaxSize];
        public int verLength;
        public int edgeLength;
        public int type; //1无向无权重 2无向有权重 3有向无权重 4有向有权重
    }
    

    代码实现的功能

    简单的查找节点和插入删除和输出自己看代码吧

    删除可能写的不太好有意见就说吧

    /**
         * create by: 睚雪
         * description: 根据顶点的名字来返回顶点
         * create time: 2020-3-16 9:25
         * @params [name]
         * @return Vertex
         */
        public Vertex getVertex(Graph graph,String name){
            Scanner bf = new Scanner(new InputStreamReader(System.in));
            for (int i = 0; i < graph.list.length; i++) {
                if(graph.list[i].verName.equals(name)){
                    return graph.list[i];
                }
            }
            return null;
        }
        /**
         * create by: 睚雪
         * description: 插入一条边
         * create time: 2020-3-17 9:04
         * @params [graph, edge]
         * @return void
         */
        public void insertEdge(Graph graph,Edge edge){
            Vertex fromvex = graph.getVertex(graph, edge.fromvex + "");
            Vertex endvex = graph.getVertex(graph, edge.endvex + "");
            if(fromvex==null||endvex==null){
                return;
            }
            Vertex vertex = new Vertex();
            vertex.verName = endvex.verName;
            vertex.next = fromvex.next;
            fromvex.next = vertex;
            if(graph.type==1||graph.type==2){
               Vertex v2 = new Vertex();
               v2.verName = fromvex.verName;
               v2.next = endvex.next;
               endvex.next = v2;
            }
        }
        /**
         * create by: 睚雪
         * description: 删除一个边
         * create time: 2020-3-17 9:11
         * @params [graph, edge]
         * @return void
         */
        public void deleteEdge(Graph graph,Edge edge){
            Vertex fromvex = graph.getVertex(graph, edge.fromvex + "");
            Vertex endvex = graph.getVertex(graph, edge.endvex + "");
    
            if(fromvex==null||endvex==null){
                return;
            }
            delete(graph,fromvex,endvex);
            if(graph.type==1||graph.type==2){
                delete(graph,endvex,fromvex);
            }
        }
    
        public void delete(Graph graph,Vertex fromvex,Vertex endvex){
            boolean flag = false;
            Vertex vertex = fromvex;
            while(true){
                if(vertex.next!=null){
                    if(!vertex.next.verName.equals(endvex.verName)){
                        vertex = vertex.next;
                    }else{
                        flag = true;
                        break;
                    }
                }else{
                    break;
                }
            }
            if(flag){
                vertex.next = vertex.next.next;
            }
    
        }
     /**
         * create by: 睚雪
         * description: 输出图
         * create time: 2020-3-16 10:09
         * @params [graph]
         * @return void
         */
        public void outputGraph(Graph graph){
            for (int i = 0; i < graph.list.length; i++) {
                System.out.print("第" + i + "个节点" + graph.list[i].verName+"他的邻接点");
                Vertex vertex = graph.list[i].next;
                while(vertex!=null){
                    System.out.print(vertex.verName+"/");
                    vertex = vertex.next;
                }
                System.out.println("");
            }
        }
    展开全文
  • 图的邻接矩阵、邻接表的表示

    千次阅读 2018-01-30 23:01:09
    关于邻接矩阵、邻接表具体包含哪些数据我就不说了,鄙人时间有点赶,大家自行百度下哈。 程序中图例子: 2.1号:补充,突然发现我程序,边权重只能为1位数,如果权重为多位数,只取个位数值,因此...
  • 若用邻接矩阵存储有向,矩阵中主对角线以下元素均为零,则关于拓扑序列结论是()。A.存在,且唯一B.存在,且不唯一C.存在,可能不唯一D.无法确定是否存在把你理解和答案发在评论区吧,关注我一下,答案...
  • 右边的矩阵即为无向的邻接矩阵表示。矩阵中第i行j列个元素Gij,若等于1则表示从i到j有边,若等于0则表示无边。 特点: 无向邻接矩阵关于主对角线对称,并且主对角线上的元素全为0 。 对于无向,第i行(或第...
  • 图的基础概念讲解 此博客介绍比较全面 例子及代码 (1)邻接矩阵:有向图和无向图都可以存储 其邻接矩阵如下:无向图的邻接矩阵关于主对角线对称 代码: ...
  • 最近有用到关于邻接矩阵的一些问题,平时不太常用所以一直没注意到networkx里面函数,权当笔记了,有兴趣查看官方文档,这里只举个小例子。 import networkx as nx # 导入必要函数包 import scipy as sp import ...
  • Status CreateDG(MGraph *G) /* create digraph */ { int i,j,k; char v1,v2; printf("Please input G.vernum,G.arcnum:"); scanf("%d,%d",&(*G).vexnum,&(*G).arcnum); ...}
  • 关于图的深度优先遍历邻接矩阵的方法,欢迎使用
  • #include #include #define maxsize 21 typedef int adjmatrix[maxsize][maxsize]; typedef struct{ int vex[maxsize]; //顶点向量 ... //邻接矩阵 int vexnum,arcnum; }Mgraph; typedef struct ele
  • 关于图Dijkstra算法(邻接矩阵版) 最近在学习图论,感觉也没有那么难…以前总觉得很难… // // main.cpp // Dijkstra ——不断从dis中选取最小值,取这个节点(该节点未曾被访问),更新dis,再从dis中找...
  • 那么我们会有两个选择,先介绍邻接矩阵图的方式 一.邻接矩阵 邻接矩阵去存图,就是开一个A[n][n]的数组代表从i到j的边的权值大小如A【i】【j】=2;意义是从i到j的边权值为2; 这里给出一个有向有权图的例子 #...
  • 其实就算一个贪心算法吧,看了很多资料,然后在自己之前写的邻接矩阵类中写,编译试了一下好像没出什么问题。代码如下,关于邻接矩阵的构造请参考之前的代码。 void Map::Dijkstra(int i) { //访问设置归0 ...
  • 定义图的结构体 #define Default_Vertex_Size 10 #define T char typedef struct GraphMtx { int MaxVertices;//最大顶点容量 int NumVertices;//图中顶点个数 int NumEdges;//图中边的条数 T *VerticesList...
  • 邻接矩阵A中,我们知道一个点(i,j)表示是是否有一条从i到j路径,但是如果是A^2呢?得到矩阵又有什么意义呢? 我们来用一个例子来说明,假设有矩阵A={{0,1,1,0,1}, {1,0,0,1,1}, {1,0,0,1,0}, {0,1,1,0,...
  • 无向图邻接矩阵的建立,难度不大,源码如下: #include&amp;lt;iostream&amp;gt; using namespace std; typedef struct { char nodes[100];//顶点表 int arcs[100][100];//边表 邻接矩阵 相邻接为...
  • 图的基本概念概念引入可以简单的说,图是由一些点,和连接点的线组成。点就是图的结点(顶点)。线就是路径(边)。(图1-1 简单的图)关于边边权:表示两个结点之间连线的距离(如结点3 到 结点2 的距离是 6 )(图1-2 有权...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 351
精华内容 140
关键字:

关于图的邻接矩阵