图的深度优先搜索和广度优先搜索

此图是以图的邻接表法作为储存方式，对图进行深度优先搜索和广度优先搜索（均是非递归）

# include <stdio.h>

# include <stdlib.h>

# define True 1

# define False 0

# define Error -1

# define OK 1

# define MAX_VERTEX_NUM 20

int visited[MAX_VERTEX_NUM];

typedef char VertexData;

typedef enum{DG,DN,UDG,UDN} GraphKind;

typedef struct ArcNode{ //弧节点结构

int adjvex;

struct ArcNode *nextarc;

// OtherInfo info;

}ArcNode;

typedef struct VertexNode{ //表头节点结构

VertexData data;

ArcNode *firstarc;

}VertexNode;

typedef struct {

VertexNode vertex[MAX_VERTEX_NUM];

int vexnum,arcnum;

GraphKind kind;

}AdjList;

//**********************关于栈的知识*******************************

typedef struct node

{

int num;

struct node *next;

}LinkStackNode, *LinkStack;

int InitStack(LinkStack *S) //初始化栈

{

(*S) = (LinkStack)malloc(sizeof(LinkStackNode));

(*S)->next = NULL;

if ((*S) != NULL)

return True;

else

return False;

}

int Push(LinkStack S, int x) //进栈

{

LinkStack temp;

temp = (LinkStack)malloc(sizeof(LinkStackNode));

if (temp == NULL)

return False;

temp->num = x;

temp->next = S->next;

S->next = temp;

return True;

}

int Pop(LinkStack S, int *x) //出栈

{

LinkStack temp;

temp = S->next;

if (temp == NULL)

return False;

*x = temp->num;

S->next = temp->next;

free(temp);

return True;

}

int IsEmpty(LinkStack S) //判断栈是否为空

{

if (S->next == NULL)

return True;

else

return False;

}

//*************************************************************************

//****************************关于队的知识**********************************************

typedef struct Node

{

int data;

struct Node *next;

}LinkQueueNode;

typedef struct

{

LinkQueueNode *front;

LinkQueueNode *rear;

}LinkQueue;

int InitQueue(LinkQueue *Q) // 链队列的初始化

{

Q->front = (LinkQueueNode *)malloc(sizeof(LinkQueueNode));

if (Q->front != NULL)

{

Q->rear = Q->front;

Q->front->next = NULL;

return (True);

}

else

return False;

}

int EnterQueue(LinkQueue *Q, int x) //链队列入队

{

LinkQueueNode *NewNode;

NewNode = (LinkQueueNode *)malloc(sizeof(LinkQueueNode));

if (NewNode != NULL)

{

NewNode->data = x;

NewNode->next = NULL;

Q->rear->next = NewNode;

Q->rear = NewNode;

return True;

}

else

return False;

}

int DeleteQueue(LinkQueue *Q, int *x) // 链队列出队

{

LinkQueueNode *p;

if (Q->front == Q->rear)

return False;

p = Q->front->next;

Q->front->next = p->next;

if (Q->rear == p)

Q->rear = Q->front;

*x = p->data;

free(p);

return True;

}

int Empty(LinkQueue *Q) //判断链栈是否为空

{

if (Q->front == Q->rear)

return True;

else

return False;

}

//*************************************************************************************

int FirstAdjVertex(AdjList *g, int v) //求v的第一个邻接点

{

int w;

ArcNode *p;

p = g->vertex[v].firstarc;

if (p == NULL)

return Error;

w = p->adjvex;

return w;

}

int NextAdjVertex(AdjList *g, int v, int w) //求v相对于w的下一个邻接点

{

int k;

ArcNode *p;

p = g->vertex[v].firstarc;

while (p->adjvex != w)

{

p = p->nextarc;

}

p = p->nextarc;

if (p == NULL)

return Error;

else

{

k = p->adjvex;

return k;

}

}

int LocateVertex(AdjList *g, VertexData v) //求顶点位置函数

{

int j = Error,k;

for (k = 0; k < g->vexnum ; k++)

if (g->vertex[k].data == v)

{

j = k;break;

}

return j;

}

void Crtadjlist(AdjList *g) //创建邻接链表

{

int n,e,i,j,k;

char vt,vh;

ArcNode *p;

printf("请输入图的顶点个数和弧的个数\n");

scanf("%d%d", &n, &e);

g->vexnum = n;

g->arcnum = e;

printf("请输入顶点信息\n");

getchar();

for (i = 0; i < n; i++)

{

scanf("%c", &(g->vertex[i].data));

g->vertex[i].firstarc = NULL;

}

printf("请输入弧的两个顶点\n");

for (k = 0; k < e; k++)

{

getchar();

scanf("%c%c",&vt,&vh);

i = LocateVertex(g,vt);

j = LocateVertex(g,vh);

p = (ArcNode *)malloc(sizeof(ArcNode));

p->adjvex = j;

p->nextarc = g->vertex[i].firstarc;

g->vertex[i].firstarc = p;

}

}

void DepthFirstSearch(AdjList *g, int v0) //深度优先搜索

{

LinkStackNode *S;

int v, w;

InitStack(&S);

Push(S, v0);

while ( !IsEmpty(S))

{

Pop(S, &v);

if (!visited[v])

{

printf("%c ",g->vertex[v].data );

visited[v] = True;

w = FirstAdjVertex(g,v);

while (w != -1)

{

if (!visited[w])

Push(S, w);

w = NextAdjVertex(g,v,w);

}

}

}

}

void TraverseGraph(AdjList *g) //深搜

{

int vi;

for (vi = 0; vi < g->vexnum ; vi++)

visited[vi] = False; //初始化标志数组

for (vi = 0; vi < g->vexnum; vi++)

if (!visited[vi])

DepthFirstSearch(g,vi);

}

void BreadthFirstSearch(AdjList *g, int v0) // 广度优先搜索

{

LinkQueue Q;

int v, w;

printf("%c ", g->vertex[v0].data);

visited[v0] = True;

InitQueue(&Q);

EnterQueue(&Q,v0);

while (!Empty(&Q))

{

DeleteQueue(&Q, &v);

w = FirstAdjVertex(g, v);

while (w != -1)

{

if (!visited[w])

{

printf("%c ",g->vertex[w].data);

visited[w] = True;

EnterQueue(&Q,w);

}

w = NextAdjVertex(g,v,w);

}

}

}

void BreadthTraverseGraph(AdjList *g) //广搜

{

int vi;

for (vi = 0; vi < g->vexnum ; vi++)

visited[vi] = False; //初始化标志数组

for (vi = 0; vi < g->vexnum; vi++)

if (!visited[vi])

BreadthFirstSearch(g,vi);

}

int main(void)

{

AdjList g;

Crtadjlist (&g);

printf("深度优先搜索遍历输出\n");

TraverseGraph(&g);

printf("\n广度优先搜索遍历输出\n");

BreadthTraverseGraph(&g);

printf("\n");

return 0;

}