具有 n 个顶点的无向连通图至少有 n-1 条边,如果只有 n-1 条边,则不会形成环,这样的图称为“生成树”。连通图可通过遍历构造生成树,非连通图的每个连通分量可构造一棵生成树,整个非连通图构造为生成森林。
下面程序调用算法 7.7、7.8,将无向图构造为生成森林,并以孩子—兄弟二叉链表存储之。
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */
#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<process.h> /* exit() */
#include<limits.h> //常量INT_MAX和INT_MIN分别表示最大、最小整数
/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAX_NAME 2 /* 顶点字符串的最大长度+1 */
typedef char ElemType[MAX_NAME];
typedef ElemType TElemType;
/* ------------------------------- 树的二叉链表(孩子-兄弟)存储表示 ----------------------------*/
typedef struct CSNode
{
TElemType data;
struct CSNode *firstchild, *nextsibling;
}CSNode, *CSTree;
/* ---------------------------------------------------------------------------------------------*/
typedef int InfoType;
typedef char VertexType[MAX_NAME];
/* --------------------------------- 图的邻接表存储表示 --------------------------------*/
#define MAX_VERTEX_NUM 20
typedef enum { DG, DN, AG, AN }GraphKind; /* {有向图,有向网,无向图,无向网} */
typedef struct ArcNode
{
int adjvex; /* 该弧所指向的顶点的位置 */
struct ArcNode *nextarc; /* 指向下一条弧的指针 */
InfoType *info; /* 网的权值指针) */
}ArcNode; /* 表结点 */
typedef struct
{
VertexType data; /* 顶点信息 */
ArcNode *firstarc; /* 第一个表结点的地址,指向第一条依附该顶点的弧的指针 */
}VNode, AdjList[MAX_VERTEX_NUM]; /* 头结点 */
typedef struct
{
AdjList vertices;
int vexnum, arcnum; /* 图的当前顶点数和弧数 */
int kind; /* 图的种类标志 */
}ALGraph;
/* ---------------------------------------------------------------------------------------------*/
/* ----------------------------- 需要用的图的邻接表存储的基本操作 ----------------------------*/
int LocateVex(ALGraph G, VertexType u)
{ /* 初始条件: 图G存在,u和G中顶点有相同特征 */
/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
int i;
for (i = 0; i < G.vexnum; ++i)
if (strcmp(u, G.vertices[i].data) == 0)
return i;
return -1;
}
Status CreateGraph(ALGraph *G)
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
int i, j, k;
int w; /* 权值 */
VertexType va, vb;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d", &(*G).kind);
printf("请输入图的顶点数,边数: ");
scanf("%d,%d", &(*G).vexnum, &(*G).arcnum);
printf("请输入%d个顶点的值(<%d个字符):\n", (*G).vexnum, MAX_NAME);
for (i = 0; i < (*G).vexnum; ++i) /* 构造顶点向量 */
{
scanf("%s", (*G).vertices[i].data);
(*G).vertices[i].firstarc = NULL;
}
if ((*G).kind == 1 || (*G).kind == 3) /* 网 */
printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
else /* 图 */
printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
for (k = 0; k < (*G).arcnum; ++k) /* 构造表结点链表 */
{
if ((*G).kind == 1 || (*G).kind == 3) /* 网 */
scanf("%d%s%s", &w, va, vb);
else /* 图 */
scanf("%s%s", va, vb);
i = LocateVex(*G, va); /* 弧尾 */
j = LocateVex(*G, vb); /* 弧头 */
p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = j;
if ((*G).kind == 1 || (*G).kind == 3) /* 网 */
{
p->info = (int *)malloc(sizeof(int));
*(p->info) = w;
}
else
p->info = NULL; /* 图 */
p->nextarc = (*G).vertices[i].firstarc; /* 插在表头 */
(*G).vertices[i].firstarc = p;
if ((*G).kind >= 2) /* 无向图或网,产生第二个表结点 */
{
p = (ArcNode*)malloc(sizeof(ArcNode));
p->adjvex = i;
if ((*G).kind == 3) /* 无向网 */
{
p->info = (int*)malloc(sizeof(int));
*(p->info) = w;
}
else
p->info = NULL; /* 无向图 */
p->nextarc = (*G).vertices[j].firstarc; /* 插在表头 */
(*G).vertices[j].firstarc = p;
}
}
return OK;
}
VertexType* GetVex(ALGraph G, int v)
{ /* 初始条件: 图G存在,v是G中某个顶点的序号。操作结果: 返回v的值 */
if (v >= G.vexnum || v < 0)
exit(ERROR);
return &G.vertices[v].data;
}
int FirstAdjVex(ALGraph G, VertexType v)
{ /* 初始条件: 图G存在,v是G中某个顶点 */
/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
ArcNode *p;
int v1;
v1 = LocateVex(G, v); /* v1为顶点v在图G中的序号 */
p = G.vertices[v1].firstarc;
if (p)
return p->adjvex;
else
return -1;
}
int NextAdjVex(ALGraph G, VertexType v, VertexType w)
{ /* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号。 */
/* 若w是v的最后一个邻接点,则返回-1 */
ArcNode *p;
int v1, w1;
v1 = LocateVex(G, v); /* v1为顶点v在图G中的序号 */
w1 = LocateVex(G, w); /* w1为顶点w在图G中的序号 */
p = G.vertices[v1].firstarc;
while (p&&p->adjvex != w1) /* 指针p不空且所指表结点不是w */
p = p->nextarc;
if (!p || !p->nextarc) /* 没找到w或w是最后一个邻接点 */
return -1;
else /* p->adjvex==w */
return p->nextarc->adjvex; /* 返回v的(相对于w的)下一个邻接顶点的序号 */
}
Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
void(*VisitFunc)(char* v); /* 函数变量(全局量) */
typedef int QElemType; /* 队列类型 */
/* ------------------------------- 单链队列--队列的链式存储结构 -------------------------------*/
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front, rear; /* 队头、队尾指针 */
}LinkQueue;
/* ---------------------------------------------------------------------------------------------*/
/* --------------------------------- 需要用到的链队列的基本操作 --------------------------------*/
Status InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
(*Q).front = (*Q).rear = (QueuePtr)malloc(sizeof(QNode));
if (!(*Q).front)
exit(OVERFLOW);
(*Q).front->next = NULL;
return OK;
}
Status QueueEmpty(LinkQueue Q)
{ /* 若Q为空队列,则返回TRUE,否则返回FALSE */
if (Q.front == Q.rear)
return TRUE;
else
return FALSE;
}
Status EnQueue(LinkQueue *Q, QElemType e)
{ /* 插入元素e为Q的新的队尾元素 */
QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
if (!p) /* 存储分配失败 */
exit(OVERFLOW);
p->data = e;
p->next = NULL;
(*Q).rear->next = p;
(*Q).rear = p;
return OK;
}
Status DeQueue(LinkQueue *Q, QElemType *e)
{ /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
QueuePtr p;
if ((*Q).front == (*Q).rear)
return ERROR;
p = (*Q).front->next;
*e = p->data;
(*Q).front->next = p->next;
if ((*Q).rear == p)
(*Q).rear = (*Q).front;
free(p);
return OK;
}
/* ---------------------------------------------------------------------------------------------*/
void Display(ALGraph G)
{ /* 输出图的邻接矩阵G */
int i;
ArcNode *p;
switch (G.kind)
{
case DG: printf("有向图\n");
break;
case DN: printf("有向网\n");
break;
case AG: printf("无向图\n");
break;
case AN: printf("无向网\n");
}
printf("%d个顶点:\n", G.vexnum);
for (i = 0; i < G.vexnum; ++i)
printf("%s ", G.vertices[i].data);
printf("\n%d条弧(边):\n", G.arcnum);
for (i = 0; i < G.vexnum; i++)
{
p = G.vertices[i].firstarc;
while (p)
{
if (G.kind <= 1) /* 有向 */
{
printf("%s→%s ", G.vertices[i].data, G.vertices[p->adjvex].data);
if (G.kind == DN) /* 网 */
printf(":%d ", *(p->info));
}
else /* 无向(避免输出两次) */
{
if (i < p->adjvex)
{
printf("%s-%s ", G.vertices[i].data, G.vertices[p->adjvex].data);
if (G.kind == AN) /* 网 */
printf(":%d ", *(p->info));
}
}
p = p->nextarc;
}
printf("\n");
}
}
/* --------------------------------------------------------------------------------------------------*/
/* 调用算法7.7、7.8 */
void DFSTree(ALGraph G, int v, CSTree *T)
{ /* 从第v个顶点出发深度优先遍历图G,建立以T为根的生成树。算法7.8 */
Boolean first = TRUE;
int w;
CSTree p, q = NULL;
VertexType v1, w1;
visited[v] = TRUE;
strcpy(v1, *GetVex(G, v));
for (w = FirstAdjVex(G, v1); w >= 0; w = NextAdjVex(G, v1, strcpy(w1, *GetVex(G, w)))) /* w依次为v的邻接顶点 */
if (!visited[w]) /* w顶点不曾被访问 */
{
p = (CSTree)malloc(sizeof(CSNode)); /* 分配孩子结点 */
strcpy(p->data, *GetVex(G, w));
p->firstchild = NULL;
p->nextsibling = NULL;
if (first)
{ /* w是v的第一个未被访问的邻接顶点 */
(*T)->firstchild = p;
first = FALSE; /* 是根的第一个孩子结点 */
}
else /* w是v的其它未被访问的邻接顶点 */
q->nextsibling = p; /* 是上一邻接顶点的兄弟姐妹结点 */
q = p;
DFSTree(G, w, &q); /* 从第w个顶点出发深度优先遍历图G,建立子生成树q */
}
}
void DFSForest(ALGraph G, CSTree *T)
{ /* 建立无向图G的深度优先生成森林的(最左)孩子(右)兄弟链表T。算法7.7 */
CSTree p, q = NULL;
int v;
*T = NULL;
for (v = 0; v < G.vexnum; ++v)
visited[v] = FALSE; /* 赋初值 */
for (v = 0; v < G.vexnum; ++v) /* 从第0个顶点找起 */
if (!visited[v])
{ /* 第v顶点为新的生成树的根结点 */
p = (CSTree)malloc(sizeof(CSNode)); /* 分配根结点 */
strcpy(p->data, *GetVex(G, v));
p->firstchild = NULL;
p->nextsibling = NULL;
if (!*T) /* 是第一棵生成树的根(T的根) */
*T = p;
else /* 是其它生成树的根(前一棵的根的"兄弟") */
q->nextsibling = p;
q = p; /* q指示当前生成树的根 */
DFSTree(G, v, &p); /* 建立以p为根的生成树 */
}
}
void PreOrderTraverse(CSTree T, void(*Visit)(TElemType))
{ /* 先根遍历孩子-兄弟二叉链表结构的树T */
if (T)
{
Visit(T->data); /* 先访问根结点 */
PreOrderTraverse(T->firstchild, Visit); /* 再先根遍历长子子树 */
PreOrderTraverse(T->nextsibling, Visit); /* 最后先根遍历下一个兄弟子树 */
}
}
void print(char *i)
{
printf("%s ", i);
}
void main()
{
ALGraph g;
CSTree t;
printf("请选择无向图\n");
CreateGraph(&g);
Display(g);
DFSForest(g, &t);
printf("先根遍历生成森林:\n");
PreOrderTraverse(t, print);
printf("\n");
}
运行结果:
非连通无向图:
![](https://i-blog.csdnimg.cn/blog_migrate/4fd98586ebb38ab133eff4bf50bdca59.png)
根据输入产生的邻接表:
![](https://i-blog.csdnimg.cn/blog_migrate/5a34204fdafc82f669cadaa884af8211.png)
生成森林:
![](https://i-blog.csdnimg.cn/blog_migrate/12ec425c3bf970365449578a49448c7b.png)
生成森林以孩子—兄弟二叉链表存储的结构:
![](https://i-blog.csdnimg.cn/blog_migrate/cbfdf1f6303930d3a3a13c21ab586612.png)