数据结构封装之《LGraph邻接表式图》

最新推荐文章于 2022-10-24 20:48:04 发布
最新推荐文章于 2022-10-24 20:48:04 发布
阅读量795 收藏 1
点赞数 3
分类专栏： 汇编（逆向） 数据与数据库 文章标签： 图 graph
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BeiJiaan/article/details/79237321
版权

说明：

  1. 邻接表是图的另一种有效的存储表示方法. 每个顶点u建立一个单链表, 链表中每个结点代表一条边《u, v》,为边结点，每个单链表相当于邻接矩阵的一行；
  2. 通过复用LinkList和LinkQueue的方法封装的LGraph，请看：
    数据结构封装之《LinkList单向链表》
    数据结构封装之《LinkQueue链式队列》

下面将给出该数据结构的代码，每个函数的结构分析 ，以及个别主要函数的汇编分析

代码：

TGraph.h

#ifndef _LGRAPH_H_
#define _LGRAPH_H_

typedef void LGraph;
typedef void LVertex;
typedef void (LGraph_Printf)(LVertex*);

//创建并返回有n个顶点的图
LGraph* LGraph_Create(LVertex** v, int n);

//销毁graph
void LGraph_Destroy(LGraph* graph);

//将graph所值图的边集合清空
void LGraph_Clear(LGraph* graph);

//在graph所值的v1和v2之间加上边，且边的权为w
int LGraph_AddEdge(LGraph* graph, int v1, int v2, int w);

//将graph所指图中v1和v2之间的边删除，返回权值
int LGraph_RemoveEdge(LGraph* graph, int v1, int v2);

//将graph所值图中v1和v2之间的权值返回
int LGraph_GetEdge(LGraph* graph, int v1, int v2);

//将graph所指图中v顶点的度数返回
int LGraph_TD(LGraph* graph, int v);

//将graph所值图中的定点数返回
int LGraph_VertexCount(LGraph* graph);

//将graph所指图中的边数返回
int LGraph_EdgeCount(LGraph* graph);

//深度优先遍历
void LGraph_DFS(LGraph* graph, int v, LGraph_Printf* pFunc);

//广度优先遍历
void LGraph_BFS(LGraph* graph, int v, LGraph_Printf* pFunc);

void LGraph_Display(LGraph* graph, LGraph_Printf* pFunc);

#endif

TGraph.c

#include <malloc.h>
#include <stdio.h>
#include "LGraph.h"
#include "LinkList.h"
#include "LinkQueue.h"

typedef struct _tag_LGraph
{
    int count;
    LVertex** v;
    LinkList** la;
} TLGraph;

typedef struct _tag_ListNode
{
    LinkListNode header;
    int v;
    int w;
} TListNode;

//深度优先递归遍历
static void recursive_dfs(TLGraph* graph, int v, int visited[], LGraph_Printf* pFunc)
{
    int i = 0;

    pFunc(graph->v[v]);//打印当前元素数据

    visited[v] = 1;//已访问的元素下标，要做标志

    printf(", ");

    //当前元素的下级元素访问
    for(i=0; i<LinkList_Length(graph->la[v]); i++)
    {
        TListNode* node = (TListNode*)LinkList_Get(graph->la[v], i);

        //检查是否被访问过，若无则进入该元素的深度遍历
        if( !visited[node->v] )
        {
            recursive_dfs(graph, node->v, visited, pFunc);
        }
    }
}

//广度优先遍历
static void bfs(TLGraph* graph, int v, int visited[], LGraph_Printf* pFunc)
{
    LinkQueue* queue = LinkQueue_Create();

    if( queue != NULL )
    {
        LinkQueue_Append(queue, graph->v + v);//将当前元素入队

        visited[v] = 1;//已访问的元素下标，要做标志

        while( LinkQueue_Length(queue) > 0 )
        {
            int i = 0;

            v = (LVertex**)LinkQueue_Retrieve(queue) - graph->v;//当前元素出队

            pFunc(graph->v[v]);//打印当前访问的元素

            printf(", ");

            //检查当前元素是否有下级元素
            for(i=0; i<LinkList_Length(graph->la[v]); i++)
            {
                TListNode* node = (TListNode*)LinkList_Get(graph->la[v], i);//逐一获取其下级元素

                if( !visited[node->v] )//检查该下级元素是否被访问过
                {
                    LinkQueue_Append(queue, graph->v + node->v);//将该没被访问的元素入队

                    visited[node->v] = 1;//入队的元素，标记已访问
                }
            }
        }
    }

    LinkQueue_Destroy(queue);
}

LGraph* LGraph_Create(LVertex** v, int n)  // O(n)
{
    TLGraph* ret = NULL;
    int ok = 1;

    if( (v != NULL ) && (n > 0) )
    {
        ret = (TLGraph*)malloc(sizeof(TLGraph));

        if( ret != NULL )
        {
            ret->count = n;

            ret->v = (LVertex**)calloc(n, sizeof(LVertex*));

            ret->la = (LinkList**)calloc(n, sizeof(LinkList*));

            ok = (ret->v != NULL) && (ret->la != NULL);

            if( ok )
            {
                int i = 0;

                for(i=0; i<n; i++)
                {
                    ret->v[i] = v[i];
                }

                for(i=0; (i<n) && ok; i++)
                {
                    ok = ok && ((ret->la[i] = LinkList_Create()) != NULL);
                }
            }

            if( !ok )
            {
                if( ret->la != NULL )
                {
                    int i = 0;

                    for(i=0; i<n; i++)
                    {
                        LinkList_Destroy(ret->la[i]);
                    }
                }

                free(ret->la);
                free(ret->v);
                free(ret);

                ret = NULL;
            }
        }
    }

    return ret;
}

void LGraph_Destroy(LGraph* graph) // O(n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;

    LGraph_Clear(tGraph);

    if( tGraph != NULL )
    {
        int i = 0;

        for(i=0; i<tGraph->count; i++)
        {
            LinkList_Destroy(tGraph->la[i]);
        }

        free(tGraph->la);
        free(tGraph->v);
        free(tGraph);
    }
}

void LGraph_Clear(LGraph* graph) // O(n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;

    if( tGraph != NULL )
    {
        int i = 0;

        for(i=0; i<tGraph->count; i++)
        {
            while( LinkList_Length(tGraph->la[i]) > 0 )
            {
                free(LinkList_Delete(tGraph->la[i], 0));
            }
        }
    }
}

int LGraph_AddEdge(LGraph* graph, int v1, int v2, int w) // O(1)
{
    TLGraph* tGraph = (TLGraph*)graph;
    TListNode* node = NULL;
    int ret = (tGraph != NULL);

    ret = ret && (0 <= v1) && (v1 < tGraph->count);
    ret = ret && (0 <= v2) && (v2 < tGraph->count);
    ret = ret && (0 < w) && ((node = (TListNode*)malloc(sizeof(TListNode))) != NULL);

    if( ret )
    {
       node->v = v2;
       node->w = w;

       LinkList_Insert(tGraph->la[v1], (LinkListNode*)node, 0);
    }

    return ret;
}

int LGraph_RemoveEdge(LGraph* graph, int v1, int v2) // O(n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int condition = (tGraph != NULL);
    int ret = 0;

    condition = condition && (0 <= v1) && (v1 < tGraph->count);
    condition = condition && (0 <= v2) && (v2 < tGraph->count);

    if( condition )
    {
        TListNode* node = NULL;
        int i = 0;

        for(i=0; i<LinkList_Length(tGraph->la[v1]); i++)
        {
            node = (TListNode*)LinkList_Get(tGraph->la[v1], i);

            if( node->v == v2)
            {
                ret = node->w;

                LinkList_Delete(tGraph->la[v1], i);

                free(node);

                break;
            }
        }
    }

    return ret;
}

int LGraph_GetEdge(LGraph* graph, int v1, int v2) // O(n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int condition = (tGraph != NULL);
    int ret = 0;

    condition = condition && (0 <= v1) && (v1 < tGraph->count);
    condition = condition && (0 <= v2) && (v2 < tGraph->count);

    if( condition )
    {
        TListNode* node = NULL;
        int i = 0;

        for(i=0; i<LinkList_Length(tGraph->la[v1]); i++)
        {
            node = (TListNode*)LinkList_Get(tGraph->la[v1], i);

            if( node->v == v2)
            {
                ret = node->w;

                break;
            }
        }
    }

    return ret;
}

int LGraph_TD(LGraph* graph, int v) // O(n*n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int condition = (tGraph != NULL);
    int ret = 0;

    condition = condition && (0 <= v) && (v < tGraph->count);

    if( condition )
    {
        int i = 0;
        int j = 0;

        for(i=0; i<tGraph->count; i++)
        {
            for(j=0; j<LinkList_Length(tGraph->la[i]); j++)
            {
                TListNode* node = (TListNode*)LinkList_Get(tGraph->la[i], j);

                if( node->v == v )
                {
                    ret++;
                }
            }
        }

        ret += LinkList_Length(tGraph->la[v]);
    }

    return ret;
}

int LGraph_VertexCount(LGraph* graph) // O(1)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int ret = 0;

    if( tGraph != NULL )
    {
        ret = tGraph->count;
    }

    return ret;
}

int LGraph_EdgeCount(LGraph* graph) // O(n)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int ret = 0;

    if( tGraph != NULL )
    {
        int i = 0;

        for(i=0; i<tGraph->count; i++)
        {
            ret += LinkList_Length(tGraph->la[i]);
        }
    }

    return ret;
}

void LGraph_DFS(LGraph* graph, int v, LGraph_Printf* pFunc)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int* visited = NULL;
    int condition = (tGraph != NULL);

    condition = condition && (0 <= v) && (v < tGraph->count);
    condition = condition && (pFunc != NULL);
    condition = condition && ((visited = (int*)calloc(tGraph->count, sizeof(int))) != NULL);

    if( condition )
    {
        int i = 0;

        //以深度优先方式，打印当前顶点的所有内容
        recursive_dfs(tGraph, v, visited, pFunc);

        //检查未访问的顶点
        for(i=0; i<tGraph->count; i++)
        {
            if( !visited[i] )
            {
                recursive_dfs(tGraph, i, visited, pFunc);
            }
        }

        printf("\n");
    }

    free(visited);
}

void LGraph_BFS(LGraph* graph, int v, LGraph_Printf* pFunc)
{
    TLGraph* tGraph = (TLGraph*)graph;
    int* visited = NULL;
    int condition = (tGraph != NULL);

    condition = condition && (0 <= v) && (v < tGraph->count);
    condition = condition && (pFunc != NULL);
    condition = condition && ((visited = (int*)calloc(tGraph->count, sizeof(int))) != NULL);

    if( condition )
    {
        int i = 0;

        //以广度优先方式，打印当前顶点的所有内容
        bfs(tGraph, v, visited, pFunc);

        //检查未访问的顶点
        for(i=0; i<tGraph->count; i++)
        {
            if( !visited[i] )
            {
                bfs(tGraph, i, visited, pFunc);
            }
        }

        printf("\n");
    }

    free(visited);
}

void LGraph_Display(LGraph* graph, LGraph_Printf* pFunc) // O(n*n*n)
{
    TLGraph* tGraph = (TLGraph*)graph;

    if( (tGraph != NULL) && (pFunc != NULL) )
    {
        int i = 0;
        int j = 0;

        for(i=0; i<tGraph->count; i++)
        {
            printf("%d:", i);
            pFunc(tGraph->v[i]);
            printf(" ");
        }

        printf("\n");

        for(i=0; i<tGraph->count; i++)
        {
            for(j=0; j<LinkList_Length(tGraph->la[i]); j++)
            {
                TListNode* node = (TListNode*)LinkList_Get(tGraph->la[i], j);

                printf("<");
                pFunc(tGraph->v[i]);
                printf(", ");
                pFunc(tGraph->v[node->v]);
                printf(", %d", node->w);
                printf(">");
                printf(" ");               
            }
        }

        printf("\n");
    }
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "LGraph.h"


void print_data(LVertex* v)
{
    printf("%s", (char*)v);
}

int main(int argc, char *argv[])
{
    LVertex* v[] = {"A", "B", "C", "D", "E", "F"};
    LGraph* graph = LGraph_Create(v, 6);

    LGraph_AddEdge(graph, 0, 1, 1);
    LGraph_AddEdge(graph, 0, 2, 1);
    LGraph_AddEdge(graph, 0, 3, 1);
    LGraph_AddEdge(graph, 1, 5, 1);
    LGraph_AddEdge(graph, 1, 4, 1);
    LGraph_AddEdge(graph, 2, 1, 1);
    LGraph_AddEdge(graph, 3, 4, 1);
    LGraph_AddEdge(graph, 4, 2, 1);

    LGraph_Display(graph, print_data);

    LGraph_RemoveEdge(graph, 0, 1, 1);
    int edgeW = LGraph_GetEdge(graph,0,2);
    int td = LGraph_TD(graph,0);
    int vc = LGraph_VertexCount(graph);
    int ec = LGraph_EdgeCount(graph);


    LGraph_DFS(graph, 0, print_data);
    LGraph_BFS(graph, 0, print_data);

    LGraph_Destroy(graph);

    return 0;
}

函数结构分析：

1.tGraph_Create

2.LGraph_Destroy

3.LGraph_Clear

4.LGraph_AddEdge

5.LGraph_RemoveEdge

6.LGraph_GetEdge

7.LGraph_TD

8.LGraph_VertexCount

9.LGraph_EdgeCount

汇编分析：

main

1.tGraph_Create

2.LGraph_Destroy

3.LGraph_Clear

4.LGraph_AddEdge

5.LGraph_RemoveEdge

6.LGraph_GetEdge

7.LGraph_TD

8.LGraph_VertexCount

9.LGraph_EdgeCount

BeiJiaan
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#数据结构练习/图/邻接表
Lucassen的博客
03-20 947
姑且先写了非递归的BFS与DFS, 以后再补上递归算法与拓扑排序吧 using System; using System.Collections.Generic; namespace DataStructurePractice { //邻接表存储的有向图 //造轮子, 手动链表实现 //使用数组代替List //本例中顶点标识暂定为string型 clas...
Graph 图－邻接表法
......
04-17 390
用邻接表法表示的双向图（改单向容易，只要修改connect,disconect方法）。 此处只是表示数据结构，没有相关算法。 其中Vertex是辅助类表示顶点，其中包含一个boolean变量isVisited表示是否遍历过。 Graph表示图，实际存储顶点，以及顶点之间的关系，用一个数组存储顶点，另一个数组中存放与对应的顶点的相连的的顶点的下标。 大部分的代码实际是辅助代码，其中包括： Verte...
C++ 数据结构图（Graph）的邻接表构造
Haku_yyf的博客
07-06 680
C++ 数据结构图（Graph）的邻接表构造
图的邻接表实现方法
chen_zan_yu_的博客
08-03 207
vector<int>G[MAX_V]; /* *边上有属性的情况 * *struct edge{int to,cost;}; *vector<edge>G[MAX_V]; */ int main() { int V,E; scanf("%d%d",&V,&E); for(int i=0;i<E;i++) { ...
图的存储结构之邻接表
qq_38158479的博客
02-14 508
//结构代码如下: /*图的邻接表存储结构*/ typedef struct EdgeNode1 /*边表结点结构*/ { EdgType adjvex;/*邻接点域，存储该顶点对应的下标*/ EdgType weight;/*这里实现的是无向网图的邻接表存储结构，所以需要一个权值，代表两个顶点的距离*/ struct EdgeNode1* next;/*链域，指向下一个邻接点*/ ...
C++数据结构之实现邻接表
12-20
本文实例为大家分享了C++数据结构之实现邻接表的具体代码，供大家参考，具体内容如下 一、图的邻接表实现 1.实现了以顶点顺序表、边链表为存储结构的邻接表； 2.实现了图的创建（有向/无向/图/网）、边的增删操作、...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
在数据结构的学习中，图是一种非常重要的非线性数据结构，用于表示对象之间的关系。图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素...
数据结构之图的邻接表建立
05-08
数据结构之图的邻接表建立
头歌数据结构图的邻接表存储及遍历操作
05-26
头歌数据结构图的邻接表存储及遍历操作 第1关图的邻接表存储及求邻接点操作 第2关图的深度遍历 第3关图的广度遍历 稳过
Graph(2)--图的实现（邻接矩阵&邻接表 ）
小钊的博客
06-26 2269
本文主要介绍图的两种实现，邻接矩阵与邻接表
算法（12）图的表示——邻接链表和邻接矩阵
白首少年的博客
01-21 1330
图有两种表示方法，邻接链表和邻接矩阵。         具体使用哪种表示方式更合适与图的属性有关。若是稀疏图（E         邻接链表的表示： struct node { int name; int length; struct node *next; }; typedef node * graph;         邻接矩阵的表示： #define V
数据结构——图
qq_64551897的博客
10-24 358
图的存储方式——邻接表表示图
数据结构 无全图单源最短路径算法
wwxy1995的博客
11-27 403
6-11 Shortest Path [1] （25 point(s)） Write a program to find the unweighted shortest distances from any vertex to a given source vertex in a digraph. Format of functions: void ShortestDist( LGraph...
数据--第41棵 - 图的存储结构
weixin_38168760的博客
08-11 66
第41棵 - 图的存储结构 1. 邻接矩阵法 用一维数组存储顶点--描述顶点相关的数据。 用二维数组存储边--描述顶点的边。 设图A = (V,E)是一个有n个顶点的图，图的邻接矩阵为Edge[n][n]，则：Edge[i][j] = W，W>0，i和j连接；Edge[i][j] = 0，i == j 或者i和j不链接。 注：W为权值，当需要权值时，取W为1表示结点间连接...
PTA–6-2-三选一 Is Topological Order (25 分)
jmu201821122110
06-09 5588
PTA–6-2-三选一 Is Topological Order (25 分) 题目如下图片 ： 题目本身的 意思很简单，就是传进来一个数组判断这个数组里面的数字能否构成一个拓扑序列 思路也很简单： 将传进来的数组用一个队列保存，然后依次出队，出队的顶点必定是 入度为0的顶点，若入度不为0，直接返回false。 队列空了之后 还没有返回 false 就说明 能够构成 一个拓扑序列。 但是 ...
Is Topological Order (25 分)【清奇思路，不同寻常】（第十三周编程实验）
爱和九九的博客
11-22 2189
6-1 Is Topological Order (25 分) Write a program to test if a give sequence Seq is a topological order of a given graph Graph. Format of functions: bool IsTopSeq( LGraph Graph, Vertex Seq[] ); where LG...
bfs算法实例c语言,C语言之图的创建 dfs bfs操作
weixin_34584910的博客
05-24 234
头文件typedef struct anode{intadjvex;structanode *next;}Anode;typedef struct vnode{intvertex;Anode*first;}Vnode;typedef struct{Vnodevex[MaxVex];intvnum;intednum;intvisited[MaxVex];}Lgraph;typedef struct ...
6-13 Topological Sort（25 分）
友人A
02-21 911
6-13 Topological Sort（25 分）Write a program to find the topological order in a digraph.Format of functions:bool TopSort( LGraph Graph, Vertex TopOrder[] ); where LGraph is defined as the following:type...
（浙大-19-夏-数据结构学习笔记+代码)图（Graph)
计算机科学与技术专业学生的成长之路
08-04 382
概念 表示“多对多”的关系 包含： 一组顶点：通常用 V 表示顶点集合； 一组边：通常用 E 表示边的集合 边是顶点对：（ V , W )（两个顶点表示） 有向边< V, W >表示从 V 指向 W 德边（单行线） 不考虑重边和自回路 数据操作集： G( v,w )由一个非空有限顶点集合和一个有限边集合 E 组成。 操作集： 常见术语： 无向图：边没有方向； 有向图：边有方...
数据结构实验图使用邻接表存储图片
最新发布
05-18
邻接表是一种常见的图存储方式，可以用于实现图的基本操作。下面是使用邻接表存储的一个无向图的示例： ![邻接表存储图示例](https://img-blog.csdnimg.cn/20210306201453559.png) 在邻接表中，每个顶点都对应一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值