图的C语言描述

最新推荐文章于 2022-01-24 01:53:43 发布
最新推荐文章于 2022-01-24 01:53:43 发布
阅读量174 收藏
点赞数 1
文章标签： c/c++ git 数据结构与算法
原文链接：https://segmentfault.com/a/1190000008744160
版权

摘要

邻接表是标示图的标准方法。图论算法中通常需要找出与某个给定顶点v邻接的所有顶点。而这可以通过简单地扫描相应的邻接表来完成，所用时间与这些顶点的个数成正比。

C语言中我们无法通过名字作为数组的索引，因此我们必须提供从名字到数字的映射。完成这项工作最容易的方法是使用散列表（HashTable），在每条边被输入的时，我们通过该散列表检查它指向的定点是否已经存在，如果不存在我们生成并将该点加入到图中且set到散列表中，如果存在我们获>取其值，即图中的数组下标。

无权图最短路径的计算需要用到队列结构。我们先将起点的known和dist属性置为1和0，入列，然后出列，将该点的所有边指的距离未知（known属性为0）的点都计算dist（所在顶点的dist+1）并置known为1然后入列，如此反复。

我们先声明图的数据结构，和相关操作方法：

#define MAX_GRAPH_V_NODE_NUM 256
#define MAX_NAME_SIZE 32 

typedef struct e_node_s {
    int idx;
    struct e_node_s *next;
} e_node_t;

typedef struct v_node_s {
    char name[MAX_NAME_SIZE];
    int known;
    int dist;
    e_node_t *first_e_node;
    e_node_t *last_e_node;
} v_node_t;

typedef struct graph_s {
    v_node_t *v_node_list[MAX_GRAPH_V_NODE_NUM];
    int v_node_num;
    int e_node_num;
} graph_t;


e_node_t *e_node_init(int idx);
v_node_t *v_node_init(char *name);
graph_t *graph_init();
int graph_add_e_node(e_node_t *e, int idx, graph_t *g);
int graph_add_v_node(v_node_t *v, graph_t *g);
v_node_t *graph_get_v_node(int idx, graph_t *g);
int graph_set_v_node(v_node_t *v, int idx, graph_t *g);

int graph_get_shortest_path(char *vname, htable_t *htable, graph_t *g);

int graph_print(graph_t *g);

具体方法的定义实现：

e_node_t *e_node_init(int idx) {
    e_node_t *e = malloc(sizeof(e_node_t));
    e->idx = idx;
    e->next = NULL;
    return e;
}

v_node_t *v_node_init(char *name) {
    v_node_t *v = malloc(sizeof(v_node_t));
    snprintf(v->name, MAX_NAME_SIZE, "%s", name);
    v->known = 0;
    v->dist = 0;
    v->first_e_node = NULL;
    v->last_e_node = NULL;
    return v;
}

graph_t *graph_init() {
    graph_t *g = malloc(sizeof(graph_t));
    g->v_node_num = 0;
    g->e_node_num = 1;
    return g;
}

int graph_add_v_node(v_node_t *v, graph_t *g) {
    g->v_node_list[g->v_node_num] = v;
    g->v_node_num ++;
    return g->v_node_num - 1;
}

v_node_t *graph_get_v_node(int idx, graph_t *g) {
    return g->v_node_list[idx];
}

int graph_set_v_node(v_node_t *v, int idx, graph_t *g) {
    g->v_node_list[idx] = v;
    return 0;
}

int graph_add_e_node(e_node_t *e, int idx, graph_t *g) {
    v_node_t *v = g->v_node_list[idx];
    if (v == NULL) {
        perror("vex is NULL!");
        return 1;
    }
    if (v->first_e_node == NULL) {
        v->first_e_node = e;
        v->last_e_node = e;
    } else {
        v->last_e_node->next = e;
        v->last_e_node = e;
    }
    g->e_node_num ++;
    return 0;
}

int graph_print(graph_t *g) {
    int j, i = 0;
    v_node_t *v;
    while (NULL != (v = g->v_node_list[i])) {
        e_node_t *e = v->first_e_node;
        j = 0;
        while (e != NULL) {
            printf("顶点[%d]%s的第%d个邻接点：[%d]%s\n", i+1, v->name,  j+1, e->idx+1, g->v_node_list[e->idx]->name);
            e = e->next;
            j ++;
        }
        i ++;
    }
    return 0;
}

int graph_get_shortest_path(char *vname, htable_t *htable, graph_t *g) {

    htable_node_t *node = htable_get(vname, htable);
    int idx = node->val;

    queue_t *q = queue_init();
    g->v_node_list[idx]->known = 1;
    g->v_node_list[idx]->dist = 0;
    enqueue(ele_init(idx), q);

    ele_t *ele;

    while (NULL != (ele = dequeue(q))) {
        v_node_t *v = g->v_node_list[ele->val];
        e_node_t *e = v->first_e_node;
        while (e != NULL) {
            if (g->v_node_list[e->idx]->known == 0) {
                g->v_node_list[e->idx]->known = 1;
                g->v_node_list[e->idx]->dist = v->dist + 1;
                enqueue(ele_init(e->idx), q);
                printf("点[%d]%s距离点[%d]%s：%d\n", e->idx, g->v_node_list[e->idx]->name, idx, vname, g->v_node_list[e->idx]->dist);
            }
            e = e->next;
        }
    }
    return 0;
}

声明散列表的结构和相关操作方法：

#define HASH_TABLE_SIZE 512
typedef struct htable_node_s {
    unsigned int hash;
    char key[MAX_NAME_SIZE];
    int val;
    struct htable_node_s *next;
} htable_node_t;

typedef struct htable_s {
    htable_node_t *table[HASH_TABLE_SIZE];
    int count;
} htable_t;

unsigned int BKDRHash(char *str);    //BKDRHash
htable_node_t *htable_node_init(unsigned int hash, char *key, int val);
htable_t *htable_init();
htable_node_t *htable_get(char *key, htable_t *htable);
int htable_set(char *key, int val, htable_t *htable);

具体方法定义实现：

// BKDR Hash Function
unsigned int BKDRHash(char *str) {
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * seed + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

htable_node_t *htable_node_init(unsigned int hash, char *key, int val) {
    htable_node_t *node = malloc(sizeof(htable_node_t));
    node->hash = hash;
    snprintf(node->key, MAX_NAME_SIZE, "%s", key);
    node->val = val;
    node->next = NULL;
    return node;
}

htable_t *htable_init() {
    htable_t *h = malloc(sizeof(htable_t));
    h->count = 0;
    return h;
}

int htable_set(char *key, int val, htable_t *htable) {
    unsigned int hash = BKDRHash(key);
    int idx = hash % HASH_TABLE_SIZE;
    htable_node_t *prev;
    htable_node_t *node = htable->table[idx];
    if (node == NULL) {
        htable->table[idx] = htable_node_init(hash, key, val);
        htable->count ++;
    } else {
         while (strcmp(node->key, key) != 0) {
            if (node->next != NULL) {
                node = node->next;
            } else {// scan to the end
                node->next = htable_node_init(hash, key, val);
                htable->count ++;
                break;
            }
        }
    }
    return 0;
}

htable_node_t *htable_get(char *key, htable_t *htable) {
    unsigned int hash = BKDRHash(key);
    int idx = hash % HASH_TABLE_SIZE;
    htable_node_t *node = htable->table[idx];
    while (node != NULL && strcmp(node->key, key) != 0) {
        node = node->next;
    }
    return node;
}

声明队列的数据结构和相关操作方法：

typedef struct ele_s {
    int val;
    struct ele_s *next;
} ele_t;

typedef struct queue_s {
    ele_t *head;
    ele_t *tail;
    int count;
} queue_t;

ele_t *ele_init(int val);
queue_t *queue_init();
ele_t *dequeue(queue_t *q);
int enqueue(ele_t *e, queue_t *q);

具体方法的定义实现：

ele_t *ele_init(int val) {
    ele_t *e = malloc(sizeof(ele_t));
    e->val = val;
    e->next = NULL;
    return e;
}

queue_t *queue_init() {
    queue_t *q = malloc(sizeof(queue_t));
    q->head = q->tail = NULL;
    q->count = 0;
    return q;
}

int enqueue(ele_t *e, queue_t *q) {
    if (q->tail == NULL) {
        q->head = e;
        q->tail = e;
        q->count = 1;
    } else {
        q->tail->next = e;
        q->tail = e;
        q->count ++;
    }
    return 0;
}

ele_t *dequeue(queue_t *q) {
    if (q->count <= 0) {
        return NULL;
    }
    ele_t *e = q->head;
    q->head = q->head->next;
    q->count --;
    if (q->count == 0) {
        q->tail = NULL;
    }
    return e;
}

编译执行：

➜  exercises git:(master) ✗ gcc graph.c
➜  exercises git:(master) ✗ ./a.out
输入图的顶点数量：
7
输入第1个顶点名字：
v1
第1个顶点[0]v1已生成
输入第1个顶点[0]v1的邻接点数量：
2
输入第1个顶点[0]v1的第1个邻接点名字：
v2
第1个顶点[0]v1的第1个邻接点v2已生成
输入第1个顶点[0]v1的第2个邻接点名字：
v4
第1个顶点[0]v1的第2个邻接点v4已生成
输入第2个顶点名字：
v2
第2个顶点v2已存在,槽位：1
输入第2个顶点[1]v2的邻接点数量：
v4
输入第2个顶点[1]v2的第1个邻接点名字：
第2个顶点[1]v2的第1个邻接点v4已生成
输入第2个顶点[1]v2的第2个邻接点名字：
v5
第2个顶点[1]v2的第2个邻接点v5已生成
输入第3个顶点名字：
v3
第3个顶点[4]v3已生成
输入第3个顶点[4]v3的邻接点数量：
2
输入第3个顶点[4]v3的第1个邻接点名字：
v1
第3个顶点[4]v3的第1个邻接点v1已生成
输入第3个顶点[4]v3的第2个邻接点名字：
v6
第3个顶点[4]v3的第2个邻接点v6已生成
输入第4个顶点名字：
v4
第4个顶点v4已存在,槽位：2
输入第4个顶点[2]v4的邻接点数量：
4
输入第4个顶点[2]v4的第1个邻接点名字：
v3
第4个顶点[2]v4的第1个邻接点v3已生成
输入第4个顶点[2]v4的第2个邻接点名字：
v5
第4个顶点[2]v4的第2个邻接点v5已生成
输入第4个顶点[2]v4的第3个邻接点名字：
v6
第4个顶点[2]v4的第3个邻接点v6已生成
输入第4个顶点[2]v4的第4个邻接点名字：
v7
第4个顶点[2]v4的第4个邻接点v7已生成
输入第5个顶点名字：
v5
第5个顶点v5已存在,槽位：3
输入第5个顶点[3]v5的邻接点数量：
1
输入第5个顶点[3]v5的第1个邻接点名字：
v7
第5个顶点[3]v5的第1个邻接点v7已生成
输入第6个顶点名字：
v6
第6个顶点v6已存在,槽位：5
输入第6个顶点[5]v6的邻接点数量：
0
输入第7个顶点名字：
v7
第7个顶点v7已存在,槽位：6
输入第7个顶点[6]v7的邻接点数量：
1
输入第7个顶点[6]v7的第1个邻接点名字：
v6
第7个顶点[6]v7的第1个邻接点v6已生成
图生成完毕！
开始打印图——
顶点[1]v1的第1个邻接点：[2]v2
顶点[1]v1的第2个邻接点：[3]v4
顶点[2]v2的第1个邻接点：[3]v4
顶点[2]v2的第2个邻接点：[4]v5
顶点[3]v4的第1个邻接点：[5]v3
顶点[3]v4的第2个邻接点：[4]v5
顶点[3]v4的第3个邻接点：[6]v6
顶点[3]v4的第4个邻接点：[7]v7
顶点[4]v5的第1个邻接点：[7]v7
顶点[5]v3的第1个邻接点：[1]v1
顶点[5]v3的第2个邻接点：[6]v6
顶点[7]v7的第1个邻接点：[6]v6
准备计算最短路径，请输入起始点：
v3
开始计算最短路径——
点[0]v1距离点[4]v3：1
点[5]v6距离点[4]v3：1
点[1]v2距离点[4]v3：2
点[2]v4距离点[4]v3：2
点[3]v5距离点[4]v3：3
点[6]v7距离点[4]v3：3

源码：https://github.com/0x5446/exe...

参考文献

  1. （美）Mark Allen Weiss 著 冯舜玺 译. 数据结构与算法分析. 机械工业出版社. 2004 各种字符串Hash函数比较

  2. 各种字符串Hash函数比较 - BYVoid

weixin_34367257
关注
软件体系结构描述语言与建模实验描述c2软件体系结构风格,软件体系结构描述语言.pdf...
weixin_36177953的博客
05-19 965
软件体系结构描述语言软件体系结构(Software Architecture)三、软件体系结构描述语言• 增加UML“4+1”View模型软件体系结构的现状• 体系结构的理解停留在直觉、逸事和传说层面• 非形式化描述– 框线图– 非形式化的陈述• 惯用的词汇传递了丰富的语义– RPC– Client-Server– Pipe and Filter– Layered– Dist...
第四章——图(c语言描述)
Mark姚
10-27 398
无向图邻接矩阵以及邻接表的构建,深度优先搜索以及广度优先搜索。 如图所示,左为邻接表，右边为图的表示。 先写邻接矩阵,相对邻接表没那么复杂. int G[MAXSIZE][MAXSIZE];//全局变量初始化就都是0 int N;//结点数 int M;//边数 直接定义为全局变量就行,用起来方便. 最简单的邻接矩阵就是这样的二维矩阵了,如果想要给图的每个结点添加数据信息,那么就改成三维矩阵，第三个维度存放结点的数据信息. 如果两结点之间有边的话,例如1结点和2结点直接有边(无向图)，那.
图——C语言
jin_jue_qi的博客
10-07 1万+
   图是一种较线性表和数更为复杂的数据结构。在图形结构中，结点的关系可以是任意的，图中任意两个数据元素之间都可能相关。 图的存储结构有数组表示法、邻接表法、十字链表法、邻接多重表。 数组表示法一般是使用两个数组分别储存数据元素的信息和数据元素之间的关系信息。一般使用一位数组来储存顶点信息，使用二维数组来储存顶点的关系（边或弧）。如图所示，横纵坐标为顶点个数 邻接表是图的一种链式存储结构。每...
图及其操作（C语言版）
坚持是一种品质
09-27 6861
图及其操作（C语言版）标签（空格分隔）： 未分类图的定义和性质： 定义: 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,R)，其中，G表示一个图，V是图G中顶点的集合，R是图G中边的集合。 顶点：在图中的数据元素通常叫做顶点。 弧头/弧尾：若<v,w>∈VR<v,w>\in VR则<v,w><v,w>表示从vv到 ww的一条弧，且称vv为弧尾或初始点，称ww为弧头或终端点。 有
7.数据结构与算法--树（二叉树--赫夫曼树）
qq_27158571的博客
01-18 259
前言 有损压缩 对于一个图片而言：图片的每个像素各自都有一个颜色，如果把16个像素混成一个颜色，那么图片的大小就会变小，但是就不那么清晰了。这就是压缩编码 无损压缩 赫夫曼编码 （知名的压缩编码方案） 例如：一个字节是8位，比如要发送'ABCD'这个4个字符，那么要用4个字节（32位）才能发出去。如果说发送方和接收方都约定用赫夫曼编码，那么可能只要发送8位就行可以了。 1.赫夫曼树（是Huffman编码前身） 1.1定义及介绍： 由相同权值的一组叶子结点所构成的二叉树可能有不同的形态和不
C语言描述C语言描述
09-14
C语言描述涵盖了以下几个核心知识点： 1. **基本语法**：C语言的基础包括变量（如整型、浮点型、字符型等）、数据类型、运算符（算术、比较、逻辑、位操作等）、控制结构（如if-else、switch-case、for、while、do-...
数据结构与算法分析（C语言描述）习题答案
08-01
《数据结构与算法分析（C语言描述）》是一本深入探讨数据结构和算法的经典教材，主要面向使用C语言编程的学习者。这本书详细介绍了各种数据结构的实现方式以及对应的算法分析，帮助读者理解如何有效地存储和处理数据...
现代编译原理：Ｃ语言描述
02-07
《现代编译原理：C语言描述》是一本深入探讨编译技术的经典著作，它为学习者提供了关于如何将高级编程语言转换为机器可执行代码的详尽知识。编译器是计算机科学中的核心组成部分，它们将程序员用高级语言书写的源...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
本资源"数据结构与算法分析--C语言描述"是针对数据结构初学者的一个优秀教材，旨在帮助读者快速掌握这一领域。 首先，数据结构是组织和存储数据的方式，它决定了数据的访问效率和处理速度。常见的数据结构包括数组...
数据结构（C语言描述）图
qq_740785701的博客
04-05 2025
1 图的基本概念 1.1 图 1.2 有向图 1.3 无向图 1.4 完全图 1.5 关联 1.6 顶点的度 1.7 子图 1.8 路 1.9 简单路 1.10 回路 1.11 有根图 1.12 连通图 1.13 连通分支 1.14 强连通分支 1.15 赋权图和网络 2 抽象数据类型图 3 图的表示法 3.1 邻接矩阵表示法 3.2 邻接表表示法 3.3 紧缩邻接表表示法 4 用邻接矩阵实现图 4.1 用邻接矩阵实现赋权有向图 4.1.1 函数GrapHinit(n,noEdge) 4.1.2 函数Gra
数据结构——邻接矩阵表示图（c语言）
Dewitt421的博客
04-23 2405
**关于图的实现方法，除了邻接矩阵还有邻接表等方法，会在后续博客中写出 邻接矩阵（即数组）来实现图难度不高，步骤分析如下： 第一步： 建立邻接矩阵 struct GNode{ int Nv;//图的顶点数 int Ne;//图的边数 int G[MaxVertexNum][MaxVertexNum];//二维数组 }; typedef struct GNode *PtrToGNode;/...
数据结构：图的表示和遍历算法C语言实现（带案例）
weixin_43464554的博客
02-07 1112
图的表示 邻接矩阵在边数相对点数较少时会浪费存储空间。使用数组和链表相结合的邻接表存储。 图的存储————邻接矩阵法 有向图中，第i个结点的出（入）度=第i行（列）的非零元素个数，第i个结点的度= 第i行和第i列的非零个数之和 无向图中，第i个结点的度 = 第i行（列）的非零元素个数，无向图的邻接矩阵是对称矩阵可压缩 对于n个顶点和e条边的图，时间复杂度是 O(n+n2+e)O(n+n^{2}+e)O(n+n2+e) #define MAXVEX 100 /*最大顶点数*/ #define INF
图的邻接表表示法（C语言）
一串代码的博客
08-19 3万+
邻接表 邻接表数据结构类型如下：#define MaxVertices 100 typedef struct node{ //边表 int adjvex; node* next; }EdgeNode; typedef struct{ //顶点表 int vertex; EdgeNode* edgenext; }VertexNode; ty
C语言描述算法的常用方法是,认识C语言 -算法描述的5种方法
weixin_30395941的博客
05-18 1万+
在 C语言中，有 5 种常用的算法描述方法：自然语言、流程图、N-S 图、伪代码和程序设计语言。1. 自然语言描述算法上一讲《算法是什么》中给出的解决问题的算法 a、算法 b 和算法 c 都是用自然语言来表示算法的(见上一节的图2)。自然语言就是我们日常使用的各种语言，可以是汉语、英语、日语等。用自然语言描述算法的优点是通俗易懂，当算法中的操作步骤都是顺序执行时比较直观、容易理解。缺点是如果算法中...
图及其应用c语言实现（数据结构复习最全笔记）（期末复习最新版）
markconca的博客
11-25 1万+
图 一.图的基本概念 1.图的定义 图是由顶点(vertex)集合及顶点间的关系组成的一种数据结构。Graph=(V,E)Graph=(V,E)其中，顶点集合 V={x|x∈某个对象数据集}V={x|x∈某个对象数据集} 是有穷非空集合；E={(x,y)|x,y∈V}E={(x,y)|x,y∈V} 是顶点间关系的有穷集合，也叫边(edge)集合。Path(x,y)Path(x,y)表示从顶...
图的邻接矩阵（C语言）
热门推荐
一串代码的博客
08-18 4万+
邻接矩阵 无向图和有向图在邻接矩阵中的表示方法： 无向图和有向图大同小异，在这里只以无向图为例，代码部分通过简单调整即可对应编译有向图邻接矩阵数据类型定义#define MaxVertices 100 //定义最大容量 typedef struct{ //包含权的邻接矩阵的的定义 int Vertices[MaxVertices]; //顶点信息的数组 int Edge[Max
数据结构——图的C语言实现
zxr916的博客
03-18 3687
1.什么是图？ 2.图的抽象数据结构 3.如何在程序中表示一个图？ 3.1 邻接矩阵 3.2 邻接表 4.图的遍历 4.1 深度优先搜索 4.2 广度优先搜索
【数据结构 | C语言】图的四种写法 及 基本方法
qq_49150070的博客
01-24 1080
图的4种写法
C语言描述的数据结构课后习题详解
"《数据结构——用C语言描述》是一本深入探讨数据结构的书籍，配合课后习题答案，适合学习者巩固理论知识并进行实践。内容涵盖顺序存储、链式存储、栈和队列等基本数据结构，以及相关的算法分析。书中提到的数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值