【数据结构】有向图（1.基于邻接表的C++实现）

最新推荐文章于 2024-08-13 16:22:10 发布
最新推荐文章于 2024-08-13 16:22:10 发布
阅读量503 收藏 2
点赞数 1
文章标签： c/c++ 数据结构与算法 大数据
原文链接：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;
}


运行结果：


 

转载于:https://www.cnblogs.com/SadGeminids/archive/2011/11/02/2233575.html

dong19892
关注
C++实现有向图邻接表的构建
08-19
C++实现有向图邻接表的构建 本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是...
C++实现有向图的邻接表表示
08-19
C++实现有向图的邻接表表示 在计算机科学和信息技术领域中，图是一种常用的数据结构，用于描述顶点和边之间的关系。在C++中，实现有向图的邻接表表示是一种常用的方法，本文将详细介绍该方法的实现细节。 一、有向...
邻接表实现图
网世的博客
12-16 465
测试类 public class TestALGraph { public static void main(String[] args){ Scanner read=new Scanner(System.in); ALGraph g=new ALGraph(); System.out.println("------------------------"); System.o
数据结构邻接表c++
最新发布
qq_63881564的博客
08-13 270
个人学习所记笔记，如有错误，请见谅
图结构系列—基于邻接表的图实现
坚持理想 面对现实
11-27 2130
上一文中介绍了基于邻接矩阵的图实现，介绍了一些邻接矩阵的一些表示优势。下面来说一下基于邻接表的描述无向图的具体实现，在实现前有一些结点类型说明一下： 首先是边信息类型： #pragma once #include using namespace std; template class EdgeNode { public: int dest; //该边的对称顶点在NodeTable中的索引值
使用邻接表的方式实现图
EthanChenJia的博客
09-17 1554
1 基本概念 1.顶点：图中的数据元素 2.边：顶点之间的连接 3.权重：边可以带权重，用来表示从一个顶点到另一个节点的成本。 4.路径：路径是由边连接的顶点组成的序列 5.环：环是有向图中国的一条起点和终点为同一个节点的路径。 6.图的分类：按边有无方向分为有向图，无向图；按边有无权重分为权重图，无权重等等。其分类方式很多，就不一一列出。 7.度：无向图中顶点的边数，有向图中还分为入度和出度。 8.连图图：若图中任意两个顶点都是连通的，称为连通图，在有向图中，称为强连通图。 2 图的存储结构 图的存储结
用邻接表实现图的构建
guangjie2333的博客
01-16 400
#include<stdio.h> #include<stdlib.h> #define MaxVertexNum 100 typedef int Vertex; //顶点下标 typedef int WeigthType; //边的权值 typedef int DataType; //顶点的数据类型 //边的定义 typedef struct ENode { Ve...
critical_path-关键路径-邻接表有向图.zip_AdjListDirNetwork.h_C++ 有向图_buffal
09-24
本资源提供了基于邻接表有向图的C++实现，用于寻找关键路径。邻接表是一种图数据结构，它以列表的形式存储图中每个顶点的邻接顶点。在有向图中，边是从一个顶点（源）指向另一个顶点（目标）。这种表示方式特别适合...
数据结构与算法实验（C++）：图的邻接表实验-代码
01-18
1）定义有向图的邻接表类，封装图的基本操作算法，包括： a.创建、销毁邻接表存储的图 b.深度优先和广度优先遍历图 c.增加一个顶点 d.增加一条弧 e.删除一条弧 2）对建立的有向图进行拓扑排序，输出拓扑序列。 2....
图的实现：邻接表
08-01
使用邻接表实现图结构，无向的、有向的、无权的和有权的都可支持。
有向图的构建（邻接表）
02-03
里面是有向图的基本操作，这是有邻接表的方式创建的， 大家可以下载看看 如果有错，请见谅
数据结构 有向图的最短路径
06-21
数据结构 在VC++环境下实现有向图的最短路径
有向图的实现
04-21
键盘输入数据，建立一个有向图的邻接表，并输出该邻接表；在有向图的邻接表的基础上计算各顶点的度，并输出；以有向图的邻接表为基础实现并输出它的拓扑排序序列；
图的邻接链表实现 头文件 模板
05-31
数据结构中图的邻接链表的头文件。包含插入节点，插入边，删除节点，删除边等功能。
【DSA】图-邻接表实现图（3）
春秋繁露
11-05 185
有关邻接表的含义已经在之前博文中说过了（图论基础） 本章将使用邻接表创建graph,给出代码实现。 为了更容易看清楚代码的实现，我这里将图论基础中的图直接复制过来。 ...
【八】【数据结构】邻接表，图，代码简单实现，深度解析
m0_74163972的博客
12-09 644
我们今天学习了邻接表存储图信息，需要三个结构体，第一个是图的结构体，第二个是顶点结构体，第三个是表结构体（也是表示顶点）。接着编写顶点结构体，成员信息要包括该顶点的信息data，也就是顶点的表示信息，我们这里用数组对应下标表示该信息，还有一个指向表结点的指针，也就是邻接表，用来表示该顶点的邻接表，达到遍历某一顶点中邻接表的所有元素的效果。从图结构体开始编写，成员信息要包括图中顶点的个数，边的个数，图的类型，以及一个数组vex，存储每一个顶点。可以验证，用邻接表表示出来的图是没有问题的。
基于邻接表实现的图的遍历
dms2017的博客
12-23 2450
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 380
何为邻接表？ 由于邻接矩阵存储图的方式，需要固定的开辟一块空间，比如顶点多，但是边很少，这样的邻接矩阵中存在大量的未利用空间。同时，使用数组的方式，虽然查询遍历方便，但是有时需要增删操作时，会比较麻烦且耗时。于是乎，引申出了邻接表，采用数组+单链表的方式实现链式存储。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值