有向图（1.基于邻接表的C++实现）

最新推荐文章于 2023-12-09 16:36:12 发布
最新推荐文章于 2023-12-09 16:36:12 发布
阅读量659 收藏 1
点赞数
分类专栏： graph

http://www.cnblogs.com/SadGeminids/archive/2011/11/02/2233575.html

　最近按BOSS要求做一个有向图，基于邻接表的实现。大部分代码还是参考网上的，然后自己修改了一些细节。参考原帖地址：http://www.cppblog.com/saha/articles/121696.html

 

　　先说优缺点吧：优点是基本功能都有了，而且还有Dijkstra算法求最短路径，使用的模板，适合各种数据；缺点是并不像他所说的那样适合大数据的图，另外就是要求一个顶点的逆邻接表（即所有以该顶点为弧头的边）时比较麻烦。

 

　　我做过测试，加入10W条边需要20+ minutes，这是个让人无法忍受的时间。大家可以自己试一下，找找到底是哪里花费了大量时间。

 

　　下一个博文分析算法效率低劣的原因，然后过几天会另外发一个基于十字链表的实现方式，而且效率至少提少2个数量级。

 

声明类头文件：

 

复制代码 
#ifndef __GRAPH_H__
#define __GRAPH_H__

#include <vector>

#define  IN
#define OUT
#define INOUT
using namespace std;

namespace graphspace
{
    template <typename weight>
    struct Edge                        //边
    {
       int nDestVertex;               //邻接顶点编号
        weight edgeWeight;             //边权重
        Edge<weight> *pNextEdge;       //下一条边

        Edge(int d, weight c, Edge<weight> *p = NULL)
            :nDestVertex(d), edgeWeight(c), pNextEdge(p)
        {}
    };

    template <typename vertexNametype, typename weight>
    struct Vertex                      //顶点
    {
        vertexNametype vertexName;     //顶点名
        Edge<weight> *pAdjEdges;       //邻接边链表

        Vertex(vertexNametype x, Edge<weight> *p = NULL)
            :vertexName(x), pAdjEdges(p)
        {}
    };

    //adjacency list based graph
    template <typename vertexNametype, typename weight>
    class ALGraph
    {
    public:
        explicit ALGraph();
        ~ALGraph();
    public:
        
        //插入结点
        bool insertAVertex(IN const vertexNametype vertexName); 

        //插入边
        bool insertAEdge(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2, IN const weight edgeWeight);

        //边是否存在
        bool edgeExist(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2);

        //输出顶点的邻接表
        void vertexAdjEdges(IN const vertexNametype vertexName);

        //删除边
        bool removeAEdge(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2, IN const weight edgeWeight);

        //获取最小权
        weight getMinWeight(IN const vertexNametype vertexName1, IN const vertexNametype vertexName2);

        //获取顶点索引
        int getVertexIndex(IN const vertexNametype vertexName);

        //获取顶点数
        int getVertexNumber();

        //获取顶点名
        vertexNametype getData(IN int index);

        //迪科斯彻算法，最短路径
        int Dijkstra(IN const vertexNametype vertexName1);

        //输出迪科斯彻
        void DijkstraPrint(IN int index, IN int sourceIndex, IN vector<int> vecPreVertex);

        friend ostream& operator<<(OUT ostream &out, IN const ALGraph<vertexNametype,weight> &graphInstance);   

    public:
        
        //获取边权
        weight getEdgeWeight(IN const Edge<weight> *pEdge);

        //将顶点的所有邻接边的权值放入数组或者vector中
        void getVertexEdgeWeight(IN const int v1, OUT vector<weight> &DistanceArray);

        vector< Vertex<vertexNametype, weight> > m_vertexArray;
    };

#include "ALGraph_realize.h"

}

#endif
复制代码


 

实现类头文件：

复制代码 
#ifndef __GRAPH_REALIZE__H_
#define __GRAPH_REALIZE__H_


template<typename vertexNametype, typename weight>
ALGraph<vertexNametype, weight>::ALGraph()
{
    //没做重复顶点处理，因为我需要的数据是从另一个系统所得，已经确保没有重复节点
    if (!m_vertexArray.empty())
    {
        m_vertexArray.clear();
    }
    
}

template<typename vertexNametype, typename weight>
ALGraph<vertexNametype, weight>::~ALGraph()
{
    vector< Vertex<vertexNametype, weight> >::iterator iter;
    for(iter = m_vertexArray.begin(); iter != m_vertexArray.end(); iter++)              //删除每个结点的邻接链表
    {
        Edge<weight> *p = iter->pAdjEdges;
        while(NULL != p)  //删除邻接链表
        {
            iter->pAdjEdges = p->pNextEdge;
            delete p;
            p = iter->pAdjEdges;
        }
    }
    if (!m_vertexArray.empty())
    {
        m_vertexArray.clear();
    }
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::insertAVertex(IN const vertexNametype vertexName)
{
    int v = getVertexIndex(vertexName);
    if (-1 != v)
    {
        cerr << "There vertex "<<vertexName<<" is existed!" << endl;
        return false;
    }

    Vertex<vertexNametype, weight> VertexInstance(vertexName, NULL);
    m_vertexArray.push_back(VertexInstance);

    return true;
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::insertAEdge(IN const vertexNametype vertexName1, 
                            IN const vertexNametype vertexName2, IN const weight edgeWeight)
{
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    while(p != NULL && p->nDestVertex != v2)     //邻接链表是否存在，并且搜索V2是否已经在邻接表中了
    {
        p = p->pNextEdge;
    }

    if (NULL == p)                 //邻接表为空，或没找到顶点V2，则添加一条边
    {
        p = new Edge<weight>(v2, edgeWeight, m_vertexArray.at(v1).pAdjEdges);    
        m_vertexArray.at(v1).pAdjEdges = p;
        return true;
    }
    if (v2 == p->nDestVertex)      //若V1，V2之间已有一条边，则加一条新的边到已存在的第一条V1->V2边之后
    {
        Edge<weight> *q = p;
        p = new Edge<weight>( v2, edgeWeight, q->pNextEdge );
        q->pNextEdge = p;
        return true;
    }
    
    return false;
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::edgeExist(IN const vertexNametype vertexName1, 
                            IN const vertexNametype vertexName2)
{
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    while(p != NULL && p->nDestVertex != v2)    
    {
        p = p->pNextEdge;
    }

    if(NULL == p)
    {
        cout<<"dont exist"<<endl;
        return false;
    }
    if(v2 == p->nDestVertex)
    {
        cout<<"exist"<<endl;
        cout << vertexName1 << ":    ";

        while(p != NULL && p->nDestVertex == v2)     //如果v1->v2之间有几条不同的边，都输出
        {
            cout << "(" << vertexName1 << "," << vertexName2 << "," << p->edgeWeight << ")  ";
            p = p->pNextEdge;
        }
        cout << endl;
        return true;
    }
}

template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::vertexAdjEdges(IN const vertexNametype vertexName)
{
    int v1 = getVertexIndex(vertexName);
    if( -1 == v1)
    {
        cerr<<"There is no vertex: "<<vertexName<<endl;
        return ;
    }

    Edge<weigh> *p = m_vertexArray.at(v1).pAdjEdges;
    cout << vertexName << ":    ";
    while( p != NULL)
    {
        cout<<"(" << vertexName << "," << getData(p->nDestVertex) <<"," << p->edgeWeight <<") ";
    }
    cout<<endl;
}

template<typename vertexNametype, typename weight>
bool ALGraph<vertexNametype, weight>::removeAEdge(IN const vertexNametype vertexName1, 
                                          IN const vertexNametype vertexName2, IN const weight edgeWeight)
{
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    Edge<weight> *q = NULL;                
    while(p != NULL && p->nDestVertex != v2 )
    {
        q = p;
        p = p->pNextEdge;
    }
    if (NULL == p)
    {
        cerr << "Edge is not found" << endl;
        return false;
    }
    while( edgeWeight != p->edgeWeight && p->nDestVertex == v2)    //搜索相同边
    {
        q = p;
        p = p->pNextEdge;
    }
    if (v2 != p->nDestVertex)
    {
        cerr << "Edge is not found" << endl;
        return false;
    }

    if( q == NULL )                                  //m_vertexArray.at(v1).pAdjEdges所指的值即为所求时
        m_vertexArray.at(v1).pAdjEdges = p->pNextEdge;
    else
      q->pNextEdge = p->pNextEdge;                   //这里如果同一条边有好几个相同值，只会删除一次
    delete p;

    return true;
}

template<typename vertexNametype, typename weight>
weight ALGraph<vertexNametype, weight>::getEdgeWeight(IN const Edge<weight> *pEdge)
{
    return pEdge->edgeWeight;
}

template<typename vertexNametype, typename weight>
void ALGraph<vertexNametype, weight>::getVertexEdgeWeight(IN const int v1, OUT vector<weight> &DistanceArray)
{
    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    int prevIndex = -1;
    weight tmp;

    while(NULL != p)
    {
        //需考虑相同边的存在，取最小的一个值
        if (prevIndex == p->nDestVertex)
        {
            if (tmp > p->edgeWeight)
            {
                DistanceArray[prevIndex] = p->edgeWeight;
            }
        }
        else
        {
            DistanceArray[p->nDestVertex] = p->edgeWeight;
            prevIndex = p->nDestVertex;
            tmp = p->edgeWeight;
        }
        
        p = p->pNextEdge;
    }
}

template<typename vertexNametype, typename weight>
weight ALGraph<vertexNametype, weight>::getMinWeight(IN const vertexNametype vertexName1, 
                                          IN const vertexNametype vertexName2)
{
    Edge<weight> *pEdge = NULL;
    int v1 = getVertexIndex(vertexName1);
    if (-1 == v1)
    {
        cerr << "There is no vertex 1" << endl;
        return false;
    }

    int v2 = getVertexIndex(vertexName2);
    if (-1 == v2)
    {
        cerr << "There is no vertex 2" << endl;
        return false;
    }

    Edge<weight> *p = m_vertexArray.at(v1).pAdjEdges;
    while (p != NULL && p->nDestVertex != v2)
    {
        p = p->pNextEdge;
    }
    if (NULL == p)
    {
        pEdge = NULL;
        return weight(0);
    }
    weight tmp = getEdgeWeight(p);
    pEdge = p;
    while (NULL != p && v2 == p->nDestVertex)   //相同边，取权值最小的一条
    {
        if (tmp > getEdgeWeight(p))
        {
            tmp = getEdgeWeight(p);
            pEdge = p;
        }
        p = p->pNextEdge;
    }
    return tmp;
}

template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::getVertexIndex(IN const vertexNametype vertexName)
{
    for (int i = 0; i < m_vertexArray.size(); i++)
    {
        if (vertexName == getData(i))
        {
            return i;
        }
    }
    return -1;
}

template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::getVertexNumber()
{
    return m_vertexArray.size();
}

template<typename vertexNametype, typename weight>
vertexNametype ALGraph<vertexNametype, weight>::getData(IN int index)
{
    return m_vertexArray.at(index).vertexName;
}

template<typename vertexNametype, typename weight>
int ALGraph<vertexNametype, weight>::Dijkstra(IN const vertexNametype vertexName1)
{
    int sourceIndex = getVertexIndex(vertexName1);
    if (-1 == sourceIndex)
    {
        cerr << "There is no vertex " << endl;
        return false;
    }
    int nVertexNo = getVertexNumber();

    //the array to record the points have been included, if included the value is true
    //else is false
    vector<bool> vecIncludeArray;
    vecIncludeArray.assign(nVertexNo, false);
    vecIncludeArray[sourceIndex] = true;

    //the array to record the distance from vertex1
    vector<weight> vecDistanceArray;
    vecDistanceArray.assign(nVertexNo, weight(INT_MAX));
    vecDistanceArray[sourceIndex] = weight(0);

    //prev array to record the previous vertex
    vector<int> vecPrevVertex;
    vecPrevVertex.assign(nVertexNo, sourceIndex);

    getVertexEdgeWeight(sourceIndex, vecDistanceArray);

    int vFrom, vTo;

    while(1)
    {
        weight minWeight = weight(INT_MAX);
        vFrom = sourceIndex;
        vTo = -1;
        for (int i = 0; i < nVertexNo; i++)
        {
            if (!vecIncludeArray[i] && minWeight > vecDistanceArray[i])
            {
                minWeight = vecDistanceArray[i];
                vFrom = i;
            }
        }
        if (weight(INT_MAX) == minWeight)
        {
            break;
        }
        vecIncludeArray[vFrom] = true;

        Edge<weight> *p = m_vertexArray[vFrom].pAdjEdges;
        while (NULL != p)
        {
            weight wFT = p->edgeWeight;
            vTo = p->nDestVertex;
            if (!vecIncludeArray[vTo] && vecDistanceArray[vTo] > wFT + vecDistanceArray[vFrom])
            {
                vecDistanceArray[vTo] = wFT + vecDistanceArray[vFrom];
                vecPrevVertex[vTo] = vFrom;
            }
            p = p->pNextEdge;
        }
                
    }

    //print the shortest route of all vertexes
    for (int i = 0; i < nVertexNo; i++)
    {
        if (weight(INT_MAX) != vecDistanceArray[i])
        {
            cout << getData(sourceIndex) << "->" << getData(i) << ": ";
            DijkstraPrint(i, sourceIndex, vecPrevVertex);
            cout << "" << vecDistanceArray[i];
            cout << endl;
        }
    }

    return 0;
}

template<typename vertexNametype, typename weight>  
void ALGraph<vertexNametype, weight>::DijkstraPrint(IN int index, IN int sourceIndex, IN vector<int> vecPreVertex)
{
    if (sourceIndex != index)
    {
        DijkstraPrint(vecPreVertex[index], sourceIndex, vecPreVertex);
    }
    cout << getData(index) << "";
}

template<typename vertexNametype, typename weight>   
ostream& operator<<(OUT ostream &out, IN  ALGraph<vertexNametype,weight> &graphInstance)
{
    int vertexNo = graphInstance.getVertexNumber();
    out << "This graph has " << vertexNo << "vertexes" << endl;

    for(int i = 0; i < vertexNo; i++)
    {
        vertexNametype x1 = graphInstance.getData(i);
        out << x1 << ":    ";

        Edge<weight> *p = graphInstance.m_vertexArray.at(i).pAdjEdges;
        while (NULL != p)
        {
            out << "(" << x1 << "," << graphInstance.getData(p->nDestVertex) << "," << p->edgeWeight << ")  ";
            p = p->pNextEdge;
        }
        out << endl;
    }
    return out;
}

#endif
复制代码

 

主程序：

复制代码 
#include <iostream>
#include <ctime>
#include <string>
#include "ALGraph.h"

using namespace std;
using namespace graphspace;

int main()
{
    ALGraph<string, int> g;
    clock_t start1,finish1;
    double duration;

    
    g.insertAVertex("A");
    g.insertAVertex("B");
    g.insertAEdge("A", "B", 16);
    g.insertAEdge("A", "B", 26);
    g.insertAEdge("A", "B", 36);
    g.insertAEdge("A", "B", 46);
    g.insertAEdge("A", "B", 6);

    g.insertAVertex("C");
    g.insertAVertex("D");
    g.insertAVertex("E");
    g.insertAVertex("F");
    cout<<g<<endl<<endl;

    g.insertAEdge("A", "B", 6);
    g.insertAEdge("A", "C", 3);
    g.insertAEdge("B", "C", 2);
    g.insertAEdge("B", "D", 5);
    g.insertAEdge("C", "D", 3);
    g.insertAEdge("C", "E", 4);
    g.insertAEdge("D", "E", 2);
    g.insertAEdge("D", "F", 3);
    g.insertAEdge("E", "F", 5);


    g.insertAEdge("B", "A", 6);
    g.insertAEdge("C", "A", 3);
    g.insertAEdge("C", "B", 2);
    g.insertAEdge("D", "B", 5);
    g.insertAEdge("D", "C", 3);
    g.insertAEdge("E", "C", 4);
    g.insertAEdge("E", "D", 2);
    g.insertAEdge("F", "D", 3);
    g.insertAEdge("F", "E", 5);

    cout<<g<<endl<<endl;

    g.Dijkstra("A");
    
    /*
    char vertex[9];
    srand((unsigned)time(0));
    string str[10000];

    for(int i=0; i<10000; i++)      //随机生成1 W个顶点
    {
        for(int j=0; j<8; j++)
        {
            vertex[j] = rand()%26 + 97;
            str[i] += vertex[j];
        }
        g.insertAVertex(str[i]);
    }
    cout<<g<<endl<<endl;

    for(int i=0; i<100000; i++)    //随机生成10W条边
    {
        int num1 = rand()%10000;
        int num2 = rand()%10000;
        int num3 = rand()%10;
        g.insertAEdge(str[num1], str[num2], num3);
    }

    string lastname = "test";
    g.insertAVertex(lastname);
    for(int i=0; i<5000; i++)     //单个顶点关联的边并不多，这里单独加一个顶点，关联5K条边
    {
        int num5 = rand()%10000;
        int num6 = rand()%10000;
        g.insertAEdge(lastname, str[num5], num6);
    }
    cout<<g<<endl<<endl;
    
    string vertex1;
    string vertex2;
    cout<<"entry 2 vertem name"<<endl;
    cin>>vertex1;
    cin>>vertex2;
    while(vertex1 != "q")
    {
        start1 = clock();
        g.edgeExist(vertex1, vertex2);
        finish1 = clock();
        duration = (double)(finish1 - start1) / CLOCKS_PER_SEC; 
        cout<<duration<<" seconds"<<endl;
        cout<<"entry 2 vertem name"<<endl;
        cin>>vertex1;
        cin>>vertex2;
    }
    */
    system("pause");
    return 0;
}
复制代码


运行结果：


 

 

happylife1527
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的构造和实现——邻接表[有向图]（c++）
sdipper的博客
11-28 2685
//环境：vs2010 //ALGraph.cpp #include &lt;iostream&gt; using namespace std; const int MaxSize=10; //图的最大顶点数 struct ArcNode //定义边表结点 { int adjvex; //邻接点域 ArcNode *next; }; template ...
C++ 有向图的邻接表表示
ChanJose的博客
03-26 4253
一、思路： 有向图的插入有向边、删除边、删除顶点和无向图的有区别。其他的和无向图的类似。 1.插入有向边<e1, e2> 只需要插入<e1, e2>边就行，不需要插入对称边<e2, e1> 2.删除边<e1,e2>： 只需要删除<e1, e2>边...
C++实现有向图的邻接表表示
12-20
本文实例为大家分享了C++有向图的邻接表表示，供大家参考，具体内容如下 一、思路： 有向图的插入有向边、删除边、删除顶点和无向图的有区别。其他的和无向图的类似。 1.插入有向边 只需要插入边就行，不需要插入对称边 2.删除边：  只需要删除边就行，不需要仔找对称边进行删除。 3.删除顶点v: 首先，要在邻接表中删除以v为头的边; 同时，也要在邻接表中删除以v为尾的边, 不能通过对称边来找，只能一个个顶点找，浪费时间。 二、实现程序： 1.DirectedGraph.h：有向图
【数据结构】有向图（1.基于邻接表的C++实现）
11-02 490
　　最近按BOSS要求做一个有向图，基于邻接表的实现。大部分代码还是参考网上的，然后自己修改了一些细节。参考原帖地址：http://www.cppblog.com/saha/articles/121696.html 　　先说优缺点吧：优点是基本功能都有了，而且还有Dijkstra算法求最短路径，使用的模板，适合各种数据；缺点是并不像他所说的那样适合大数据的图，另外就是要求一个顶点...
邻接表实现图
网世的博客
12-16 448
测试类 public class TestALGraph { public static void main(String[] args){ Scanner read=new Scanner(System.in); ALGraph g=new ALGraph(); System.out.println("------------------------"); System.o
图结构系列—基于邻接表的图实现
坚持理想 面对现实
11-27 2103
上一文中介绍了基于邻接矩阵的图实现，介绍了一些邻接矩阵的一些表示优势。下面来说一下基于邻接表的描述无向图的具体实现，在实现前有一些结点类型说明一下： 首先是边信息类型： #pragma once #include using namespace std; template class EdgeNode { public: int dest; //该边的对称顶点在NodeTable中的索引值
使用邻接表的方式实现图
EthanChenJia的博客
09-17 1529
1 基本概念 1.顶点：图中的数据元素 2.边：顶点之间的连接 3.权重：边可以带权重，用来表示从一个顶点到另一个节点的成本。 4.路径：路径是由边连接的顶点组成的序列 5.环：环是有向图中国的一条起点和终点为同一个节点的路径。 6.图的分类：按边有无方向分为有向图，无向图；按边有无权重分为权重图，无权重等等。其分类方式很多，就不一一列出。 7.度：无向图中顶点的边数，有向图中还分为入度和出度。 8.连图图：若图中任意两个顶点都是连通的，称为连通图，在有向图中，称为强连通图。 2 图的存储结构 图的存储结
C++实现有向图邻接表的构建
08-19
C++实现有向图邻接表的构建 本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是...
critical_path-关键路径-邻接表有向图.zip_AdjListDirNetwork.h_C++ 有向图_buffal
09-24
本资源提供了基于邻接表有向图的C++实现，用于寻找关键路径。邻接表是一种图数据结构，它以列表的形式存储图中每个顶点的邻接顶点。在有向图中，边是从一个顶点（源）指向另一个顶点（目标）。这种表示方式特别适合...
用邻接表实现图的构建
guangjie2333的博客
01-16 390
#include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 typedef int Vertex; //顶点下标 typedef int WeigthType; //边的权值 typedef int DataType; //顶点的数据类型 //边的定义 typedef struct ENode { Ve...
图的实现：邻接表
08-01
使用邻接表实现图结构，无向的、有向的、无权的和有权的都可支持。
有向图的构建（邻接表）
02-03
里面是有向图的基本操作，这是有邻接表的方式创建的， 大家可以下载看看 如果有错，请见谅
数据结构 有向图的最短路径
06-21
数据结构 在VC++环境下实现有向图的最短路径
有向图的实现
04-21
键盘输入数据，建立一个有向图的邻接表，并输出该邻接表；在有向图的邻接表的基础上计算各顶点的度，并输出；以有向图的邻接表为基础实现并输出它的拓扑排序序列；
【DSA】图-邻接表实现图（3）
春秋繁露
11-05 170
有关邻接表的含义已经在之前博文中说过了（图论基础） 本章将使用邻接表创建graph,给出代码实现。 为了更容易看清楚代码的实现，我这里将图论基础中的图直接复制过来。 ...
【八】【数据结构】邻接表，图，代码简单实现，深度解析
最新发布
m0_74163972的博客
12-09 608
我们今天学习了邻接表存储图信息，需要三个结构体，第一个是图的结构体，第二个是顶点结构体，第三个是表结构体（也是表示顶点）。接着编写顶点结构体，成员信息要包括该顶点的信息data，也就是顶点的表示信息，我们这里用数组对应下标表示该信息，还有一个指向表结点的指针，也就是邻接表，用来表示该顶点的邻接表，达到遍历某一顶点中邻接表的所有元素的效果。从图结构体开始编写，成员信息要包括图中顶点的个数，边的个数，图的类型，以及一个数组vex，存储每一个顶点。可以验证，用邻接表表示出来的图是没有问题的。
基于邻接表实现的图的遍历
dms2017的博客
12-23 2438
1：首先是头文件和全局变量的写入和定义： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define MAXSIZE 20 char vex[MAXSIZE] ; //存储读入的节点信息 int outDegree[MAXSIZE], inDegree[...
图 -- 邻接表实现
GuoningningPro的博客
01-18 358
何为邻接表？ 由于邻接矩阵存储图的方式，需要固定的开辟一块空间，比如顶点多，但是边很少，这样的邻接矩阵中存在大量的未利用空间。同时，使用数组的方式，虽然查询遍历方便，但是有时需要增删操作时，会比较麻烦且耗时。于是乎，引申出了邻接表，采用数组+单链表的方式实现链式存储。
【数据结构】图 邻接表实现
l634007854的博客
11-21 273
//无向图的邻接表 #include<iostream> using namespace std; const int MAX = 10; struct ArcNode{ //边节点 int adjvex; //存储图中节点的下标 ArcNode * next; }; typedef struct { int vertex; //存储图中节点的数据 ArcNode * firstEdge; //表头指针 }vertexNode[MAX]; class ALGraph{ p...
c++实现有向图邻接表
05-15
有向图邻接表的实现可以使用C++的STL库的vector和list容器来实现。vector用来存储图中所有结点的信息，list存储每个节点的邻接表信息。 下面是一个简单的有向图邻接表的实现： ```c++ #include #include #...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值