图和往作为最一般的数据结构，在工程中十分常见。
本文采用邻接表方法，给出有向数据图和有向数据网的搭建，插入，搜索与删除的关键算法。
其他辅助函数与代码请读者自行完成。
另外，又再此基础上给出图和网的两种遍历核心算法;
其中，广度优先遍历方法使用了队列这一辅助结构临时存贮数据。
我将此辅助结写入到头文件中，下面一并给出。
#include<stdio.h>
#include<stdlib.h>
#include “queue.h”
//邻接表节点结构体：
typedef struct enode {
int AdjVex;
int W;
struct enode* NextArc;
}ENode;
//图（或网）结构体：
typedef struct graph {
int Vertices;
ENode** A;
}Graph;
//搭建图（或网）：
void CreateGraph(Graph* g, int n) {
int i;
g->Vertices = n;
g->A = (ENode**)malloc(n * sizeof(ENode*));
for (i = 0; i < n; i++) {
g->A[i] = NULL;
}
}
//创建图的新节点：
ENode* NewENode(int vex, int weight, ENode* nextarc) {
ENode* p;
p = (ENode*)malloc(sizeof(ENode));
p->AdjVex = vex;
p->W = weight;
p->NextArc = nextarc;
return p;
}
//搜索：
int Exist(Graph* g, int u, int v) {
int n;
ENode* p;
n = g->Vertices;
if (u < 0 || u>n - 1) {
return 0;
}
for (p = g->A[u]; p && p->AdjVex != v; p = p->NextArc);
if (!p) {
return 0;
}
else {
return 1;
}
}
//插入
void Add(Graph* g, int u, int v, int w) {
int n;
ENode* p;
n = g->Vertices;
if (u<0 || v<0 || u>n - 1 || v>n - 1 || Exist(g, u, v)) {
printf(“BadInput\n”);
}
p = NewENode(v, w, g->A[u]);
g->A[u] = p;
}
//删除
void Delete(Graph* g, int u, int v) {
int n = g->Vertices;
ENode* p, * q;
if (u > -1 && u < n) {
p = g->A[u];
q = NULL;
while (p && p->AdjVex != v) {
q = p;
p = p->NextArc;
}
if § {
if (q) {
q->NextArc = p->NextArc;
}
else {
g->A[u] = p->NextArc;
}
free§;
printf(“Delete Successfully!\n”);
}
else {
printf(“Cannot find!\n”);
}
}
else {
printf(“Bad Input!\n”);
}
}
//深度优先遍历算法：
void DFS(Graphg, int v, int visited) {
ENode w;
visited[v] = 1;
printf("%d ",v);
for (w = g->A[v]; w; w = w->NextArc) {
if (!visited[w->AdjVex]) {
DFS(g, w->AdjVex, visited);
}
}
}
//深度优先遍历启动函数：
void Traversal_DFS(Graph g) {
int n = g->Vertices;
int i;
int visited[100];
for (i = 0; i < n;i++) {
visited[i] = 0;
}
for (i = 0; i < n;i++) {
if (!visited[i]) {
DFS(g, i, visited);
}
}
}
//广度优先遍历算法：
void BFS(Graph g, int v, int visited) {
ENode* w;
int u;
Queue q;
q=CreateQueue( 100);
visited[v] = 1;
printf("%d ", v);
Append(q, v);
while (!isEmpty(q)) {
QueueFront(q,&u);
Serve(q);
for (w = g->A[u]; w; w = w->NextArc) {
if (!visited[w->AdjVex]) {
printf("%d ", w->AdjVex);
visited[w->AdjVex] = 1;
Append(q, w->AdjVex);
}
}
}
}
//广度优先遍历启动函数：
void Traversal_BFS(Graph g) {
int n = g->Vertices;
int i;
int visited[100];
for (i = 0; i < n; i++) {
visited[i] = 0;
}
for (i = 0; i < n; i++) {
if (!visited[i]) {
BFS(g, i, visited);
}
}
}
//打印：
void PrintArrayMatrix(Graph g) {
int i;
ENode p;
for (i = 0; i < g->Vertices; i++) {
printf("%d: “, i);
for (p = g->A[i]; p != NULL; p = p->NextArc) {
printf(”[%d][%d] “, p->AdjVex, p->W);
}
printf(”\n");
}
printf("**********\n");
}
//测试主函数：
void main() {
Graph g;
g = (Graph)malloc(sizeof(Graph));
CreateGraph(g, 8);
PrintArrayMatrix(g);
Add(g, 0, 3, 1);
Add(g, 1, 5, 1);
Add(g, 1, 2, 1);
Add(g, 1, 0, 1);
Add(g, 2, 5, 1);
Add(g, 3, 4, 1);
Add(g, 3, 1, 1);
Add(g, 4, 7, 1);
Add(g, 4, 0, 1);
Add(g, 5, 3, 1);
Add(g, 5, 6, 1);
Add(g, 6, 3, 1);
Add(g, 6, 4, 1);
Add(g, 7, 6, 1);
PrintArrayMatrix(g);
Traversal_BFS(g);
}
队列头文件：
#ifndef QUEUE_H
#define QUEUE_H
#include<stdio.h>
#include<stdlib.h>
typedef struct queue {
int front, rear, maxqueue;
int element[100];
}Queue;
Queue* CreateQueue(int m) {
Queue* q;
q= (Queue*)malloc(sizeof(Queue));
q->front = q->rear = 0;
q->maxqueue = m;
return q;
}
int isEmpty(Queue q) {
return q.front == q.rear;
}
int isFull(Queue q) {
return (q.rear + 1) % q.maxqueue == q.front;
}
void Append(Queue*q, int x) {
if (isFull(*q)) {
printf(“overflow\n”);
}
else {
q->rear = (q->rear + 1) % q->maxqueue;
q->element[q->rear] = x;
}
}
void Serve(Queue *q) {
if (isEmpty(*q)) {
printf(“underflow\n”);
}
else {
q->front = (q->front + 1) % q->maxqueue;
}
}
void QueueFront(Queue q,int *x) {
if (isEmpty(q)) {
printf(“underflow”);
}
else {
*x = q.element[(q.front + 1) % q.maxqueue];
}
}
void PrintQueue(Queue *q) {
int i;
for (i = q->front+1; i <= q->rear;i++) {
printf("%d “,q->element[i]);
}
printf(”\n");
}
#endif