精华内容
下载资源
问答
  • 摘 要:针对视频帧的时域特性,提出一种以帧间相关性构建带权值无向图的视频隐写分析方法。首先,分别计算待检测视频每帧亮度的灰度共生矩阵,把得出的8维特征作为该帧的特征向量。再以视频帧为节点,用帧间特征向量...
  • 来个小例子(无向图): 图1 上图邻接表的结构: 邻接表用链表来存储邻接点(分两个域,一个存顶点下标,一个存下一个邻接点的引用),通过一个类(我用了内部类,所以是private)定义邻接点: private class ...

    邻接表是数组与链表相结合的存储方法,相比于顺序存储结构(邻接矩阵),节省空间。
    来个小例子(无向图):
    图图1

    图1邻接表的结构:
    这里写图片描述
    邻接表用链表来存储邻接点(分两个域,一个存顶点下标,一个存下一个邻接点的引用),通过一个类(我用了内部类,所以是private)定义邻接点:

    private class AdgvexType {
            int verNum = -1;//存储顶点数组下标,默认零
            AdgvexType adg = null;//存储下一个邻接点的引用
    
            public int getVerNum() {
                return verNum;
            }
    
            public void setVerNum(int verNum) {
                this.verNum = verNum;
            }
    
            public int getWeightNum() {
                return weightNum;
            }
    
            public void setWeightNum(int weightNum) {
                this.weightNum = weightNum;
            }
    
            public AdgvexType getAdg() {
                return adg;
            }
    
            public void setAdg(AdgvexType adg) {
                this.adg = adg;
            }
    
            @Override
            public String toString() {
                return "AdgvexType [verNum=" + verNum + ", weightNum=" + weightNum
                        +  "]";
            }
    
        }

    邻接表用数组存储图的顶点,数组中每个元素包含两个域(一个存顶点,一个存它第一个临界点的引用),定义顶点数组:

    private VertexeType[] verArr;// 顶点数组
    
        // 顶点数据
        private class VertexeType {
            String vertexe = null;//存储顶点
            AdgvexType adg = null;//存储第一个邻接点的引用
    
            public VertexeType() {
            }
    
            public VertexeType(String vertexe) {
                this.vertexe = vertexe;
            }
    
            public String getVertexe() {
                return vertexe;
            }
    
            public void setVertexe(String vertexe) {
                this.vertexe = vertexe;
            }
    
            public AdgvexType getAdg() {
                return adg;
            }
    
            public void setAdg(AdgvexType adg) {
                this.adg = adg;
            }
    
            @Override
            public String toString() {
                return "VertexeType [vertexe=" + vertexe + ", adg=" + adg + "]";
            }
    
        }

    再说说带权值的有向图(在原来的基础上):
    这里写图片描述图2
    需要多记录一项属性(权值),对邻接点类型加一个域,来存储权值,结构如下:
    这里写图片描述
    class AdgvexType类加一条属性(成员变量)即可:

    int weightNum = 0;

    通过构造方法为顶点数组赋值:

        public AdjacencyList(String[] arr) {
            this.MAXVEX = arr.length;
            this.verArr = new VertexeType[this.MAXVEX];
            for (int i = 0; i < arr.length; i++) {
                this.verArr[i] = new VertexeType(arr[i]);
            }
        }

    通过二维数组添加所有邻接点:

        public void addAdg(String[][] arr) {
            for (int i = 0; i < arr.length; i++) {
                AdgvexType temp = null;
                int[] pos = this.getPosition(arr[i]);
                AdgvexType adg = new AdgvexType();
                adg.setWeightNum(Integer.valueOf( arr[i][2]));//设置权值
                adg.setVerNum(pos[1]);
                temp = this.verArr[pos[0]].getAdg();
                if (temp == null) {
                    this.verArr[pos[0]].setAdg(adg);
                    continue;
                }
                while (true) {
                    if (temp.getAdg() != null) {
                        temp = temp.getAdg();
                    } else {
                        temp.setAdg(adg);
                        break;
                    }
                }
            }
    
        }
        //查找顶点位置
        private int[] getPosition(String[] arr) {
            int[] arrInt = new int[2];
            for (int i = 0; i < this.MAXVEX; i++) {
                if (this.verArr[i].getVertexe().equals(arr[0])) {
                    arrInt[0] = i;
                    break;
                }
            }
            for (int i = 0; i < this.MAXVEX; i++) {
                if (this.verArr[i].getVertexe().equals(arr[1])) {
                    arrInt[1] = i;
                    break;
                }
            }
            return arrInt;
        }

    测试代码:

    package com.nuc.Graph;
    
    public class TestAdg {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            // TODO Auto-generated method stub
                    String[] str={"v0","v1","v2","v3"};
                    AdjacencyList adj=new AdjacencyList(str);
                    String[][] edges=new String[][]{
                            {"v0","v3","5"},//顶点,顶点,权值
                            {"v1","v0","1"},
                            {"v1","v2","3"},
                            {"v2","v0","7"},
                            {"v2","v1","4"}
                    };
                    adj.addAdg(edges);
                    adj.show();
        }
    
    }

    下边是完整代码:

    import java.util.Arrays;
    
    public class AdjacencyList {
        private int MAXVEX;// 顶点数组长度
        private VertexeType[] verArr;// 顶点数组
    
        // 顶点数据
        private class VertexeType {
            String vertexe = null;
            AdgvexType adg = null;
    
            public VertexeType() {
            }
    
            public VertexeType(String vertexe) {
                this.vertexe = vertexe;
            }
    
            public String getVertexe() {
                return vertexe;
            }
    
            public void setVertexe(String vertexe) {
                this.vertexe = vertexe;
            }
    
            public AdgvexType getAdg() {
                return adg;
            }
    
            public void setAdg(AdgvexType adg) {
                this.adg = adg;
            }
    
            @Override
            public String toString() {
                return "VertexeType [vertexe=" + vertexe + ", adg=" + adg + "]";
            }
    
        }
    
        // 边表节点
        private class AdgvexType {
            int verNum = -1;
            int weightNum = 0;
            AdgvexType adg = null;
    
            public int getVerNum() {
                return verNum;
            }
    
            public void setVerNum(int verNum) {
                this.verNum = verNum;
            }
    
            public int getWeightNum() {
                return weightNum;
            }
    
            public void setWeightNum(int weightNum) {
                this.weightNum = weightNum;
            }
    
            public AdgvexType getAdg() {
                return adg;
            }
    
            public void setAdg(AdgvexType adg) {
                this.adg = adg;
            }
    
            @Override
            public String toString() {
                return "AdgvexType [verNum=" + verNum + ", weightNum=" + weightNum
                        +  "]";
            }
    
        }
    
        // 初始化,为顶点数组赋值
        public AdjacencyList(String[] arr) {
            this.MAXVEX = arr.length;
            this.verArr = new VertexeType[this.MAXVEX];
            for (int i = 0; i < arr.length; i++) {
                this.verArr[i] = new VertexeType(arr[i]);
            }
        }
    
        public void addAdg(String[][] arr) {
            for (int i = 0; i < arr.length; i++) {
                AdgvexType temp = null;
                int[] pos = this.getPosition(arr[i]);
                AdgvexType adg = new AdgvexType();
                adg.setVerNum(pos[1]);
                temp = this.verArr[pos[0]].getAdg();
                if (temp == null) {
                    this.verArr[pos[0]].setAdg(adg);
                    continue;
                }
                while (true) {
                    if (temp.getAdg() != null) {
                        temp = temp.getAdg();
                    } else {
                        temp.setAdg(adg);
                        break;
                    }
                }
            }
    
        }
    
        private int[] getPosition(String[] arr) {
            int[] arrInt = new int[2];
            for (int i = 0; i < this.MAXVEX; i++) {
                if (this.verArr[i].getVertexe().equals(arr[0])) {
                    arrInt[0] = i;
                    break;
                }
            }
            for (int i = 0; i < this.MAXVEX; i++) {
                if (this.verArr[i].getVertexe().equals(arr[1])) {
                    arrInt[1] = i;
                    break;
                }
            }
            return arrInt;
        }
    
        public void show() {
            for (VertexeType v : verArr) {
                if (v.getAdg() == null) {
                    System.out.println(v);
                    continue;
                }
                AdgvexType temp = v.getAdg();
                String s = v + "-->" + temp;
                while (true) {
                    if (temp.getAdg() != null) {
                        temp = temp.getAdg();
                        s +="-->"+ temp;
                    } else {
                        System.out.println(s);
                        break;
                    }
                }
            }
        }
    
    }
    
    展开全文
  • 绘制无向图并在图中标记权值

    千次阅读 2017-12-14 11:38:50
    共有五个顶点,a,b,c,d,e,绘制出相应的连通,并在相应的边上标记 import networkx as nx    G=nx.Graph()    G.add_edge('a','b',weight=0.1) G.add_edge('a','c',weight=0.3) G.add_edge('b','c',weight=0.1)...

    共有五个顶点,a,b,c,d,e,绘制出相应的连通图,并在相应的边上标记

    import networkx as nx  

      
    G=nx.Graph()  
     
    G.add_edge('a','b',weight=0.1)
    G.add_edge('a','c',weight=0.3)
    G.add_edge('b','c',weight=0.1)
    G.add_edge('c','d',weight=0.2)
    G.add_edge('c','e',weight=0.1) 


    elargse=[(u,v) for (u,v,d) in G.edges(data=True)]
    pos=nx.spring_layout(G)


    nx.draw_networkx_nodes(G,pos,node_size=700)
    nx.draw_networkx_edges(G,pos,width=3)
    nx.draw_networkx_labels(G,pos,font_size=20)

    nx.draw_networkx_edge_labels(G,pos,{('a', 'b'):0.1, ('a', 'c'):0.3, ('b', 'c'):0.1, ('c', 'd'):0.2, ('c', 'e'):0.1},font_size=20)



    展开全文
  • 一、 无向图(无权值)的邻接矩阵存储方式及其DFS,BFS遍历 邻接矩阵的储存表示: 广度优先遍历需要用到队列操作,因此还需要定义一下队列的存储结构 具体代码: #include <stdio.h> #define MaxVex 100 /...

    求下图中无向图的邻接矩阵与邻接表储存方式及其DFS,BFS遍历

    在这里插入图片描述


    一、 无向图(无权值)的邻接矩阵存储方式及其DFS,BFS遍历

    邻接矩阵的储存表示:

    在这里插入图片描述
    广度优先遍历需要用到队列操作,因此还需要定义一下队列的存储结构

    在这里插入图片描述


    具体代码:

    #include <stdio.h>
    
    #define MaxVex     100            //最大顶点数
    #define TRUE       1
    #define FALSE   0
    
    typedef char    VertexType;    //顶点类型
    typedef int     EdgeType;    //权值类型
    typedef int     Bool;
    
    Bool  visited[MaxVex];
    
    typedef struct {
        VertexType vexs[MaxVex];            //顶点数组
        EdgeType   arc[MaxVex][MaxVex];    //邻接矩阵
        int        numVertexes, numEdges;   //当前图中的结点数以及边数
    }MGraph;
    
    
    //广度优先遍历需要的循环队列
    typedef struct {
        int    data[MaxVex];
        int    front, rear;
    }Queue;
    
    
    /****************************************/
    //队列的相关操作
    
    //初始化
    void InitQueue(Queue *Q)
    {
        Q->front = Q->rear = 0;
    }
    
    //入队
    void EnQueue(Queue *Q, int e)
    {
        if ((Q->rear+1)%MaxVex == Q->front)
            return ;
    
        Q->data[Q->rear] = e;
        Q->rear = (Q->rear+1)%MaxVex;
    }
    
    //判空
    Bool QueueEmpty(Queue *Q)
    {
        if (Q->front == Q->rear)
            return TRUE;
        else
            return FALSE;
    }
    
    //出队
    void DeQueue(Queue *Q, int *e)
    {
        if (Q->front == Q->rear)
            return ;
    
        *e = Q->data[Q->front];
        Q->front = (Q->front+1)%MaxVex;
    }
    /****************************************/
    
    
    //建立图的邻接矩阵
    void CreateMGraph(MGraph *G){
        int i, j, k;
    
        printf("输入顶点数和边数: ");
        scanf("%d%d", &G->numVertexes,&G->numEdges);
    
        printf("==============================\n");
        scanf("%c", &G->vexs[i]); /*关键,必须先要输入一次*/
        printf("输入各个顶点:\n");
        for (i=0; i< G->numVertexes; ++i){
            scanf("%c", &G->vexs[i]);
        }
    
        for (i=0; i<G->numVertexes; ++i){
            for (j=0; j<G->numVertexes; ++j)
                G->arc[i][j] = 0;
            fflush(stdin);
        }
    
        printf("==============================\n");
        printf("输入边(vi, vj)中的下标i和j: \n");
        for (k=0; k< G->numEdges; ++k){
            scanf("%d%d", &i,&j);
            G->arc[i][j] = 1;
            G->arc[j][i] = G->arc[i][j];
        }
    }
    
    /****************************************/
    //图的深度优先遍历
    void DFS(MGraph G, int i){
        int j;
        visited[i] = TRUE;
        printf("%c ", G.vexs[i]);
    
        for (j=0; j<G.numVertexes; ++j){
            if (G.arc[i][j]!=0 && !visited[j])
                DFS(G, j);
        }
    }
    
    void DFSTraverse(MGraph G){
        int i;
        for (i=0; i<G.numVertexes; ++i)
            visited[i] = FALSE;
    
        for (i=0; i<G.numVertexes; ++i){
            if (!visited[i])
                DFS(G, i);
        }
    
    }
    
    
    //图的广度优先遍历
    void BFSTraverse(MGraph *G){
        int i, j;
        Queue Q;
    
        for (i=0; i< G->numVertexes; ++i)
            visited[i] = FALSE;
        InitQueue(&Q);
    
        for (i=0; i< G->numVertexes; ++i){
            if (!visited[i]){
                visited[i] = TRUE;
                printf("%c ", G->vexs[i]);
                EnQueue(&Q, i);
    
                while (!QueueEmpty(&Q)){
                    DeQueue(&Q, &i);
                    for (j=0; j< G->numVertexes; ++j){
                        if (!visited[j] && G->arc[i][j]!=0){
                            visited[j] = TRUE;
                            printf("%c ", G->vexs[j]);
                            EnQueue(&Q, j);
                        }
                    }
                }
            }
        }
    }
    /****************************************/
    
    //程序入口
    int main(){
        MGraph G;
    
        CreateMGraph(&G);
    
        printf("\n图的深度优先遍历为: ");
        DFSTraverse(G);
    
        printf("\n图的广度优先遍历为: ");
        BFSTraverse(&G);
    
        printf("\n");
    
        return 0;
    }
    

    结果展示:
    在这里插入图片描述


    二、 无向图(无权值)的邻接表存储方式及其DFS,BFS遍历

    在这里插入图片描述


    具体代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define MaxVertexNum 50 /*定义最大顶点数*/
    
    typedef struct node {
        /*边表节点*/
        int adjVex;  /*邻接点域*/
        struct node* next; /*链域*/
    }EdgeNode;
    
    typedef struct vNode {
        char verTex; /*顶点域*/
        EdgeNode *firstEdge; /*边表头指针*/
    }verTexNode;
    
    typedef verTexNode AdjList[MaxVertexNum]; /*AdjList是邻接表类型*/
    
    
    typedef struct {
        AdjList adjList; /*邻接表*/
        int n,e; /*顶点数和边数*/
    }ALGraph;
    
    
    /*建立图的邻接表*/
    void CreatALGraph(ALGraph *G) {
        char a;
        int i,j,k;
        EdgeNode *s; /*定义边表节点*/
        printf("Input VertexNum(n) and EdgesNum(e):");
        scanf("%d,%d",&G->n,&G->e); /*输入顶点数和边数*/
        scanf("%c",&a); /*避免 G->adjList[0].verTex = '\n' */
        printf("Input Vertex string: ");
        for (i = 0; i < G->n; ++i) {
            scanf("%c",&a);
            G->adjList[i].verTex = a; /*读入顶点信息*/
            G->adjList[i].firstEdge = NULL; /*边表置空*/
        }
        printf("Input edges, Creat Adjacency List\n");
        for ( k = 0; k < G->e; ++k) {
            scanf("%d%d",&i,&j); /*读入边(Vi, Vj ) 的顶点对序号*/
            s = (EdgeNode *) malloc(sizeof(EdgeNode)); /*生成边表节点*/
            s->adjVex = j;
            s->next = G->adjList[i].firstEdge;
            G->adjList[i].firstEdge = s;
            s = (EdgeNode *)malloc(sizeof(EdgeNode));
            s->adjVex = i;
            s->next = G->adjList[j].firstEdge;
            G->adjList[j].firstEdge = s;
        }
    }
    
    /*定义标志向量,为全局变量*/
    typedef enum {FALSE, TRUE} Boolean;
    Boolean visited[MaxVertexNum];
    
    /*DFS遍历算法*/
    void DFSM(ALGraph *G, int i){
        EdgeNode *p;
        printf("%c",G->adjList[i].verTex);
        visited[i] = TRUE;
        p = G->adjList[i].firstEdge;
        while (p) {
            if (!visited[p->adjVex])
                DFSM(G, p->adjVex);
            p = p->next;
        }
    }
    
    void DFS(ALGraph *G){
        int i;
        for (i = 0; i < G->n; ++i) {
            visited[i] = FALSE;
        }
        for ( i = 0; i < G->n; ++i) {
            if (!visited[i]) {
                DFSM(G,i);
            }
        }
    }
    
    /*BFS 遍历算法*/
    void BFS(ALGraph *G, int k){
        int i, f=0, r= 0;
        EdgeNode *p;
        int cQueue[MaxVertexNum]; /*定义FIFO队列*/
        for (i = 0; i < G->n; ++i) {
            visited[i] = FALSE;
        }
    
        for ( i = 0; i < G->n; ++i) {
            cQueue[i] = -1; /*初始化标志向量*/
        }
        printf("%c", G->adjList[k].verTex);
        visited[k] = TRUE;
        cQueue[r] = k;
        while (cQueue[f] != -1){
            i = cQueue[f];
            f++;
            p = G->adjList[i].firstEdge;
            while (p) {
                if (!visited[p->adjVex]){
                    printf("%c", G->adjList[p->adjVex].verTex);
                    visited[p->adjVex] = TRUE;
                    r++;
                    cQueue[r] = p->adjVex;
                }
                p = p->next;
            }
        }
    }
    
    
    void main() {
        ALGraph *G = (ALGraph *)malloc(sizeof(ALGraph));
        CreatALGraph(G);
        printf("Print Graph DFS:");
        DFS(G);
        printf("\n");
        printf("Print Graph BFS:");
        BFS(G,0);
    }
    
    

    结果展示:

    在这里插入图片描述


    总结:

    1. 邻接矩阵是实现各种算法最简单的一种方式,其简单性主要来自数组读取元素的简洁性。但是其空间效率不高,适用于稠密图的存储。
    2. 邻接链表表示法,提高了空间的利用率,读取以某一节点为起点的所有边是比较简单的。但是链表的先天劣势就是随机读取方面需要移动指针,这就造成了算法的执行速度会比使用数组要慢许多。当然我们可以通过封装方法以及重载运算符的方式实现数组的功能,但是这只是代码层面的模仿,效率上是不可弥补的。除此之外,当要获得以某一节点为终点的所有边时,使用邻接表就显得十分无力了,算法实现显得十分笨拙:通过遍历所有节点的边链表,以检查是否存在满足条件的边。这里也突出了邻接矩阵的优势:它的随机读取方面的优势。
    3. DFS,BFS遍历代码并不难理解,断点调试,分析代码运行过程,很快就能够理解。推荐工具: JetBrains公司旗下的C语言开发工具,Clion

    在这里插入图片描述

    展开全文
  • Python语言,用邻接矩阵实现图 通过二维数组建立无向图 通过二维数组建立有向图 通过边建立有向图 为方便查看,通过NetworkX显示图。
  • 邻接矩阵存储带权值无向图

    千次阅读 2017-04-26 12:52:21
    "请依次输入无向图中相关联的顶点(0表示第一个顶点)及权值" ; int a, b; for ( int i = 0 ;i ;++i) { cin >> a >> b; cin >> adjacentMatrix[a][b]; adjacentMatrix[b][a] = adjacentMatrix[a]...

    vertex.h

    #pragma once
    
    class vertex
    {
    public:
        char data;//节点用字符表示
        vertex(char c=' ');
        bool isVisited;//是否被访问过
        void visited();
    };

    vertex.cpp

    #include"vertex.h"
    # include<iostream>
    using namespace std;
    //构造函数,初始时未被访问,所以为false
    vertex::vertex(char c) :data(c), isVisited(false)
    {
    }
    
    void vertex::visited()
    {
        cout << data << " ";
    }

    undiGraph(adjacent marix).h

    #pragma once
    # include"vertex.h"
    //undigraph:无向图
    //matrix: 矩阵
    //adjacency: 邻接
    # define MAX 65535
    
    //带权无向图的邻接矩阵方式存储
    class myUndiGraph
    {
    public:
        myUndiGraph(int vertex,int edge);//i:顶点个数,j:边数
        ~myUndiGraph();
        void create();//创建邻接矩阵存储的无向图
        void traverMatrix();//遍历邻接矩阵
        //double *getVertex(double x);//获取元素
        void DFS(int i);//depth first search深度优先搜索
        void BFS(int j);//breath first search广度优先搜索
        void setVisitedFalse();//记得搜索前将顶点的访问标设为false
    private:
        int iVertex;//顶点数
        int iEdge;//边数
        double **adjacentMatrix;//邻接矩阵
        vertex* vertexInfo;//顶点信息
    };
    

    undiGraph(adjacent marix).cpp

    # include"undiGraph(adjacent marix).h"
    # include<iostream>
    # include"myQuene.h"
    using namespace std;
    
    myUndiGraph::myUndiGraph(int i,int j):iVertex(i),iEdge(j),adjacentMatrix(NULL)
    {
        this->adjacentMatrix = new double*[i];
        vertexInfo = new vertex[iVertex];
        for (int k = 0;k < i;++k)
        {
            adjacentMatrix[k] = new double[i];
        }
    
        for (int i1 = 0;i1 < i;i1++)
            for (int j1 = 0;j1 < i;j1++)
                if(i1==j1)
                    adjacentMatrix[i1][j1] = 0;//对角线为0
                else adjacentMatrix[i1][j1] = MAX;
    }
    
    myUndiGraph::~myUndiGraph()
    {
        for (int i1 = 0;i1 < iVertex;i1++)
            delete[]adjacentMatrix[i1];
    
        delete []adjacentMatrix;
        delete[]vertexInfo;
    }
    
    void myUndiGraph::create()
    {
        cout << "请输入顶点信息:" << endl;
        for (int i = 0;i < iVertex;i++)
            cin >> vertexInfo[i].data;
        cout << "请依次输入无向图中相关联的顶点(0表示第一个顶点)及权值" << endl;
    
        int a, b;
        for (int i = 0;i < iEdge;++i)
        {
            cin >> a >> b;
            cin >> adjacentMatrix[a][b];
            adjacentMatrix[b][a] = adjacentMatrix[a][b];        
        }
    }
    
    void myUndiGraph::traverMatrix()
    {
        for (int i1 = 0;i1 < iVertex;i1++)
        {
            for (int j1 = 0;j1 < iVertex;j1++)
                cout << adjacentMatrix[i1][j1] << "\t";
            cout << endl;
        }
    }
    
    void myUndiGraph::DFS(int i)//depth first search深度优先搜索
    {
        //从第一个节点开始搜索(下标为0)
        if (!vertexInfo[i].isVisited)//如果第i+1个节点为被访问
        {
            vertexInfo[i].visited();
            vertexInfo[i].isVisited = true;
        }
        for (int j = i+1;j < iVertex;j++)//在第i+1个顶点的邻接点中遍历
        {
            if (adjacentMatrix[i][j] != MAX)
                DFS(j);
        }
    }
    void myUndiGraph::BFS(int j)//breath first search广度优先搜索
    {   
        if (!vertexInfo[j].isVisited)//如果该节点为访问
        {
            vertexInfo[j].visited();
            vertexInfo[j].isVisited = true;
        }
        myQuene<int> m(30);
        m.in(j);
        int x;
        while (!m.empty())
        {
    
            m.out(x);
            for (int i = x + 1;i < iVertex;++i)
            {
    
                if (adjacentMatrix[x][i] != MAX)//第j+1个节点的所有邻接点
                {
    
                    if (!vertexInfo[i].isVisited)
                    {
                        vertexInfo[i].visited();
                        vertexInfo[i].isVisited = true;
                        m.in(i);
                    }
                }
            }
        }
    }
    
    void myUndiGraph::setVisitedFalse()
    {
        for (int i = 0;i < iVertex;++i)
            vertexInfo[i].isVisited = false;
    }

    main.cpp

    # include<iostream>
    # include"undiGraph(adjacent marix).h"
    
    using namespace std;
    
    int main()
    {
        myUndiGraph m(8, 9);
    
        m.create();
        cout << "\n此图的邻接矩阵为:\n";
        m.traverMatrix();
    
        cout << "深度优先搜索结果为:" << endl;
        m.DFS(0);
        cout << endl;
    
        m.setVisitedFalse();//记得将访问标志设为false
        cout << "广度优先搜索结果为:" << endl;
        m.BFS(0);
        cout << endl;
        system("pause");
        return 0;
    }

    其中myQuene是之前实现的队列
    来测试一下,比如这个图
    这里写图片描述
    这里写图片描述

    展开全文
  • 1:带权值无向图

    千次阅读 2013-09-05 16:30:22
    1: 前面已经介绍了无向图是不带权值的 ,现在看带权值无向图 权值 的定义类 两个点 一个权重   /** * 边 * @author lijunqing */ public class Edge implements Comparable&lt;Edge&gt; { ...
  • 算法——图之无向图

    万次阅读 2017-05-23 19:25:51
    图的概念 ...图可以分为无向图(简单连接),有向图(连接有方向),加权图(连接带权值),加权有向图(连接既有方向又有权值)。 这篇讨论无向图无向图的表示方法: 1.邻接矩阵 2.边的数组 3.邻接表
  • 复旦大学2017复试上机第三题——无向图的最小权值连通子图(prim算法的邻接矩阵实现) 题目: 一个无向图,顶点为N个,其中M条边已给定,现在要从K条备选边中选出若干条,使得整个图连通,且选出的边权值和最小。 ...
  • 无权无向图、带权无向图的实现 java 邻接矩阵实现无权无向图、带权无向图 java 1.图的接口 import java.util.List; public interface Graph { public int getSize(); //返回图中的顶点数 public List getVertices();...
  • 一般存储图的方式有两种:一是用邻接矩阵表示,二是用邻接链表。 所谓用邻接矩阵,是用一个二维数组存储,边...无向图的边的矩阵一定是一个对称矩阵,因为无向图只关心边是否存在,而不关心方向,V0和V1有边,那么...
  • 输出两行信息,第一行输出该中连通子图的个数。第二行按照升序输出每个连通子图中顶点个数。 输入: 输入数据第一行为两个正整数n(1)和m(1),分别表示顶点数和边数。后面紧跟m行数据,每行数据是一条边的...
  • 图的基本操作(无向图

    千次阅读 2020-05-22 22:50:52
    的定义 (Graph)在是一种较线性表和树更为复杂的数据结构。 在线性表中,数据元素之间是被串起来的,只有线性关系,每个数据元素只有一个直接前驱和一个直接后继。 在树形结构中,数据元素之间有着很明显的...
  • C++邻接矩阵构造无向图和无向网

    千次阅读 2019-05-31 21:24:57
    假设我们要创建一个无向图的邻接矩阵 #include<iostream> #define OK 1 #define ERROR 0 #define MaxNum 100 //最大顶点数 typedef char VexType; //顶点数据类型为char型 typedef int VarType; //边的...
  • 最小生成树 加权无向图

    千次阅读 2018-11-06 13:45:11
    最小生成树 加权图:为每条边关联一个权值...一幅加权无向图的最小生成树是它的一棵权值(树中所有边的权值之和)最小的生成树。 计算最小生成树的两种经典算法:Prim算法 和 Kruskal算法 在计算最小生成树的过程...
  • 文章目录带权无向图的邻接矩阵表示法(C语言实现)一、邻接矩阵表示法二、本次程序实现的功能三、带权无向图的结构体定义四、创建无向图及邻接矩阵五、输出邻接矩阵六、输出顶点集合七、判断两顶点是否邻接八、全部...
  • 无向图寻找两点间的最短路径

    千次阅读 2018-10-17 08:10:02
     无向图是图结构的一种。本次程序利用邻接表实现无向图,并且通过广度优先遍历找到两点之间的最短路径。   2.广度优先遍历  广度优先遍历(BFS)和深度优先遍历(DFS)是图结构中最常用的遍历方式。其中广度优先...
  • 一心想学习算法,很少去真正...首先画出一幅无向图如下,标出各个节点之间的权值。 更多Python视频、源码、资料加群683380553免费获取 其中对应索引: A ——&gt; 0 B ——&gt; 1 C ——&gt; ...
  • 如题,问题是这样的:有一赋权无向连通,可以从任意一结点出发,求遍历所有结点的最小权值路线。结束点也是任意的,每个节点也没有访问次数的限制,但必须每个节点都要被访问到。,想问一下用什么算法呢?
  • 对于一个带负权值边的有向图,实现Bellman-Ford算法,求出从指定顶点s到其余顶点的最短路径,并判断图中是否存在负环。 Bellman-Ford算法的基本思路 对图中的边进行V-1轮操作(为什么是V-1轮?除了起始点,就只有V-1...
  • 用python实现迪杰斯特拉算法,单源最短路径,有向图权值无负值,用邻接矩阵来存储有向图,实现路径存储和路径打印
  • 问题描述:n个村庄之间的无向图,边上的权值w(i,j)表示村庄i和j之间道路长度.现要从这n个村庄中选择一个村庄新建一所医院,使离医院最远的村庄到医院的路程最短.设计一程序求解此问题. 基本要求: 用邻接矩阵...
  • 一起来创建一个无向图吧!

    千次阅读 2019-11-26 09:25:40
    创建可是遍历的基础呢,虽然写了广度优先遍历()和深度优先遍历(DFS),但是自己对于创建这一块还是想再来一遍(once again?),基础也是很重要的。         我们都...
  • 下列代码的功能是使用Prim算法求出无向图的最小生成树权值总和,请补全。 给出的图用邻接矩阵存储。若两顶点之间没有直接路径,则对应权值为 INF,且题目保证 INF 值足够大;若找不到距离最短的顶点或者无法求出权值...
  • 知识的学习在于点滴记录,坚持不懈;知识的学习要有深度和广度,不能只流于表面,坐井观天;知识要善于总结,不仅能够...这篇文章主要输出完整的有向图的相关代码,关于无向图和有向图的理论,很多数据结构的书籍...
  • 我们把有向图缩点为有向的缩点树,则某一强连通块的权值就是该连通块下的 所有正点权值和   这样我们就可以得到一个有向环图,显然我们选择的起点是入度为0 的点,因为所有入度不为0的点 都能从别的点走
  • 邻接表创建无向图

    千次阅读 2019-05-31 17:39:16
    System.out.println("输入边数(边数不能超过无向图最大边数):"); int edgeNum = sc.nextInt(); graph.setVertexNum(vertexNum); graph.setEdgeNum(edgeNum); //初始化顶点数组 for(int i = 0; i ; i++){...
  • 有向图和无向图以及拓扑的复习

    万次阅读 2018-10-14 17:43:36
    有向图和无向图的定义 1)关于有向图,百科中是这样描述的:一个有向图D是指一个有序三元组(V(D),A(D),ψD),其中ψD为关联函数,它使A(D)中的每一个元素(称为有向边或弧)对应于V(D)中的一个有序元素(称为顶点或点...
  • 有向图和无向图用邻接矩阵储存

    千次阅读 2017-12-29 21:27:14
    般存储图的方式有两种:一是用邻接矩阵表示,二是用邻接链表。 所谓用邻接矩阵,是用一个二维数组存储,边使用矩阵来构建模型,这使得每一...无向图的边的矩阵一定是一个对称矩阵,因为无向图只关心边是否存在,而不
  • 下图为一个无向图的邻接表结构 在图中 data和firstedge在顶点表中,data存储顶点的信息firstedge指向边表的第一个结点。 边表结点由adjvex与next两个域组成,其中adjvex用于存储某顶点的邻接点在顶点表的下标。next...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,509
精华内容 17,803
关键字:

无向图的最大权值