DFS递归与非递归算法（C语言）

头文件（DFS.h）

#include<iostream>
using namespace std;
#define INF 32767
#define MAXV 100
typedef char InfoType;
typedef struct ANode
{
	int adjvex;
	struct ANode *nextarc;
	int weight;
}ArcNode;
typedef struct Vnode
{
	InfoType info;
	ArcNode *firstarc;
}VNode;
typedef struct
{
	VNode adjlist[MAXV];
	int n, e;
}AdjGraph;
typedef struct stack
{
	ArcNode* dfs[MAXV];
	int top;
}Sqstack;

void CreateAdj(AdjGraph *&G, int a[MAXV][MAXV], int n, int e);
void DisAdj(AdjGraph *G);
void DestroyAdj(AdjGraph*&G);
void DFS(AdjGraph *G, int v);
void InitStack(Sqstack *&s);
void DestroStack(Sqstack*&s);
bool Push(Sqstack *&s, ArcNode* e);
bool Pop(Sqstack *s, ArcNode *&e);
bool EmptyStack(Sqstack *s);
void FDFS(AdjGraph *G, int v);

DFS.cpp

#define _CRT_SECURE_NO_WARNINGS
#include"DFS.h"
void CreateAdj(AdjGraph *&G, int a[MAXV][MAXV], int n, int e)
{
	int i, j;
	ArcNode *p;
	G = new AdjGraph;
	for (i = 0; i<n; i++)
		G->adjlist[i].firstarc = NULL;
	for (i = 0; i<n; i++)
		for (j = n - 1; j >= 0; j--)
			if (a[i][j] != INF && a[i][j] != 0)
			{
		p = new ArcNode;
		p->adjvex = j;
		p->weight = a[i][j];
		p->nextarc = G->adjlist[i].firstarc;
		G->adjlist[i].firstarc = p;
			}
	G->e = e;
	G->n = n;
}
void DisAdj(AdjGraph *G)
{
	int i;
	ArcNode *p;
	for (i = 0; i<G->n; i++)
	{
		p = G->adjlist[i].firstarc;
		cout << i << ":";
		while (p != NULL)
		{
			printf("%3d[%d]->", p->adjvex, p->weight);
			p = p->nextarc;

		}
		cout << endl;

	}
}
void DestroyAdj(AdjGraph*G)
{
	int i;
	ArcNode *p, *pre;
	for (i = 0; i<G->n; i++)
	{
		pre = G->adjlist[i].firstarc;
		p = pre->nextarc;
		while (pre != NULL)
		{
			delete pre;
			pre = p;
			p = pre->nextarc;
		}
		delete pre;
	}
	delete G;
}
int visited[MAXV] = { 0 };//一开始放在里面，导致该数组不断被初始化
void DFS(AdjGraph *G, int v)
{
	ArcNode *p;
	visited[v] = 1;
	printf("%d ",v);
	p = G->adjlist[v].firstarc;
	while (p != NULL)
	{
		if (visited[p->adjvex] == 0)
			DFS(G, p->adjvex);
		p = p->nextarc;
	}

}
void InitStack (Sqstack *&s)
{
	s = new Sqstack;
	s->top = -1;
}
void DestroStack(Sqstack*&s)
{
	delete s;
}
bool Push(Sqstack *&s, ArcNode* e)
{
	if (s->top == MAXV - 1)
		return false;
	s->dfs[++s->top] = e;
	return true;
}
bool Pop(Sqstack *s, ArcNode* &e)
{
	if (s->top == -1)
		return false;
	e = s->dfs[s->top--];
	return true;
}
bool GetPop(Sqstack *s, ArcNode* &e)
{
	if (s->top == -1)
		return false;
	e = s->dfs[s->top];
	return true;
}
bool EmptyStack(Sqstack *s)
{
	if (s->top == -1)
		return true;
	else
		return false;
}
int visited2[MAXV] = { 0 };
void FDFS(AdjGraph *G, int v)//非递归算法
{
	Sqstack *s;
	InitStack(s);
	ArcNode *e;
	ArcNode *q;
	Push(s,G->adjlist[v].firstarc);//将元素v的邻接点的地址（即v指向邻接点的指针）压入栈中
	visited2[v] = 1;//记v被访问过
	printf("%d ", v);
	while (!EmptyStack(s))//栈是否为空
	{
		GetPop(s,q);//取栈顶元素
			while (q!=NULL)
			{
				if (visited2[q->adjvex] == 0)//如果该邻接点没被访问过
				{
					visited2[q->adjvex] = 1;
					printf("%d ", q->adjvex);
					Push(s,G->adjlist[q->adjvex].firstarc);//将该邻接点指向的指针压入栈中
					break;
				}
				else//如果该点被访问过，即已经打印出来了
				{
					q = q->nextarc;//q指向当前的下个邻接点
					if (q == NULL)//意味着在当前元素的邻接点都被访问过了
						Pop(s, e);//pop出来
				}
			};
	}
	while (s->top > -1)
	{
		Pop(s,e);
		printf("%d ", e->adjvex);
	}
	DestroStack(s);
}

exp

#define _CRT_SECURE_NO_WARNINGS
#include"DFS.h"
int main()
{
	AdjGraph *g;
	int n, e;
	cin >> n >> e;
	int a[MAXV][MAXV] = {
			{ 0, 5, INF, 7, INF, INF },
			{ INF, 0, 4, INF, INF, INF },
			{ 8, INF, 0, INF, INF, 9 },
			{ INF, INF, 5, 0, INF, 6 },
			{ INF, INF, INF, 5, 0, INF },
			{ 3, INF, INF, INF, 1, 0 } };

	int i, j;
	CreateAdj(g, a, n, e);
	DisAdj(g);
	DFS(g, 0);
	printf("\n");
	FDFS(g, 0);
	printf("\n");
	system("pause");
	return 0;
}