用邻接表存储有向图并实现DFS（递归+非递归）BFS（非递归）两种遍历

代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
using namespace std;
#define MAX 20
typedef char Dtype;
typedef int mapmax[MAX][MAX];
int visited[MAX];

//-----------邻接表--------------
typedef char Diantype;
//弧的结构体 
typedef struct ArcNode{
    int         adddain;//指向顶点位置的指针 
    struct  ArcNode   *nextarc;//指向下一条弧的指针 
}ArcNode,*Arc;
//点的结构体 
typedef struct VNode{
    Diantype	data;//顶点信息 
    ArcNode		*firstarc;//指向第一条依附该点的弧的指针 
}VNode, AdjList[MAX];
typedef  struct{
      AdjList	toulist;	//所有头节点的表 
      int	dian,hu;	//当前顶点数和弧数
}ALG;     
int locate_dian(ALG H,Diantype a);
void Creat_ALG(ALG &H);

//-------------栈------------------
typedef struct{
	Arc *base;
	int top;
	int size;
}Stack;

int  Gettop(Stack S,Arc &e);
void Pop(Stack &S,Arc &e);
void Push(Stack &S,Arc e);
int Isempty(Stack S);
void InitStack(Stack &S);
//------------队列----------------------
typedef struct {	//队列 
	int *base;
	int front;
	int rear;
	int tag;
}Sq;
void InitSq(Sq &QQ);
int Getlen(Sq QQ);
int Isempty(Sq QQ);
void InSq(Sq &QQ,int e);
void OutSq(Sq &QQ,int &e);
void GetHead(Sq QQ); 
//-------------DFS-----------------
int first(ALG H,int v);//递归
void dfs1_ALG(ALG H,int i);	//递归深度遍历  
void DFS(ALG H,int v);
//---------------bfs------------------
void BFS(ALG H)
{
	memset(visited,0,sizeof(visited));
	Sq q;	InitSq(q);
	int u;
	for(int i=1;i<=H.hu;i++)
	{
		if(!visited[i])
		{	visited[i]=1;	cout<<H.toulist[i].data;
			InSq(q,i);
			ArcNode *p;
			while(!Isempty(q))
			{
				OutSq(q,u);
				if(!visited[u])
				{
					cout<<H.toulist[u].data;
					visited[u]=1;
				}
				if(H.toulist[u].firstarc)
				{
					p=H.toulist[u].firstarc;
				}
				while(p)
				{
					if(!visited[p->adddain])
					{
						cout<<H.toulist[p->adddain].data;	visited[p->adddain]=1;
						InSq(q,p->adddain);
					}
					p=p->nextarc;
				}
				/*for(int w=FirstAdjVex(G,u);w>= 0;w=NextAdjVex(G,u,w))	//注释掉之后为有向图 
				{
                    if( !visited[w])
					{
						visited[w]=1;	cout<<H.toulist[u].data;
                        InSq(q,w);
                    }//if
                }*/
			}
		}
	}
}

int main()
{
	ALG A;
	Creat_ALG(A);
	memset(visited,0,sizeof(visited));
	//----------DFS 递归+非递归-------------- 
/*	for(int i=1;i<=A.dian;i++)
	{
		if(!visited[i])
			dfs1_ALG(A,i);//递归 
			DFS(A,i);	//非递归 
	}
*/
	//-----------BFS-------------------------
	printf("\nBFS结果如下\n");
	BFS(A);
	
	return 0;
}
//-------------------dfs fei dugui---------------
void DFS(ALG H,int v)
{
	Stack S;InitStack(S);
	visited[v]=1;	cout<<H.toulist[v].data;
	ArcNode *p=H.toulist[v].firstarc;
	while(p || !Isempty(S))
	{
		while(p)
		{
			if(visited[p->adddain])
				p=p->nextarc;
			else
			{
				cout<<H.toulist[p->adddain].data;	visited[p->adddain]=1;
				Push(S,p);	p=H.toulist[p->adddain].firstarc;
			}
		}
		if(!Isempty(S))
			{
				Pop(S,p);	p=p->nextarc;
			}
	}
	
}


//---------------digui DFS----------------
int first(ALG H,int v)
{
	ArcNode *p=H.toulist[v].firstarc;
	if(!p)
		return 0;
	else
	{
		while(p->nextarc)
		{
			if(!visited[p->adddain])
			{
				return p->adddain;
				break;
			}
			p=p->nextarc;
		}
		if(!visited[p->adddain])
			return p->adddain;
		return 0;
	}
}
void dfs1_ALG(ALG H,int i)	//递归深度遍历 
{
	int w;
	visited[i]=1;	cout<<H.toulist[i].data<<endl;
	for(w=first(H,i);w>0;w=first(H,i))
	{
		if(!visited[w])
			dfs1_ALG(H,w);
	}
}
//---------------邻接表---------------------- 
int locate_dian(ALG H,Diantype a)
{
	for(int i=1;i<=H.dian;i++)
	{
		if(H.toulist[i].data==a)
			return i;
	}
	return 0;
}
void Creat_ALG(ALG &H)
{//根据输入的有向图G的顶点数及边数，建立图G的邻接表
	printf("请输入点数和弧数\n");
	cin>>H.dian>>H.hu;
	getchar();
	printf("请输入节点信息\n");
	for(int i=1;i<=H.dian;i++)
	{
		cin>>H.toulist[i].data;
		H.toulist[i].firstarc=NULL;
	}
	getchar();
	printf("请输入%d条弧\n",H.hu);
	for(int k=1;k<=H.hu;k++)
	{
		Diantype x,y;
		int i,j;
		ArcNode *p,*node;
		cin>>x>>y;	getchar();
		i=locate_dian(H,x);j=locate_dian(H,y);
		//----i->j-------
		node=new ArcNode;
		node->adddain=j;	node->nextarc=NULL;
		p=H.toulist[i].firstarc;
		if(!p)
			H.toulist[i].firstarc=node;
		else
			{
				while(p->nextarc)
					p=p->nextarc;
				p->nextarc=node;
			}
		//----j->i--------
		/*node=new ArcNode;
		node->adddain=i;	node->nextarc=NULL;
		p=H.toulist[j].firstarc;
		if(!p)
			H.toulist[j].firstarc=node;
		else
		{
			while(p->nextarc)
				p=p->nextarc;
			p->nextarc=node;
		}
		*/
	}
}
//---------------------栈-----------------
//初始化 
void InitStack(Stack &S)
{
	S.base=(Arc*)malloc(MAX*sizeof(ArcNode));
	if(!S.base)
		return ;
	S.top=0;
	S.size=MAX;
}
//判空操作，返回 1 表示栈为空 
int Isempty(Stack S)
{
	if(S.top==0)
		return 1;
	return 0;
}
//入栈操作
void Push(Stack &S,Arc e)
{
	if(S.top>=S.size)
	{
		printf("该栈已满\n");
		return ;	
	}

	S.base[S.top++]=e;
}
//出栈操作
void Pop(Stack &S,Arc &e)
{
	if (Isempty(S))    return;     //栈为空 
    e = S.base[--S.top];
}
//Gettop 取栈顶元素
int  Gettop(Stack S,Arc &e){
 //若栈不空则用e返回S的栈顶元素
 
   if (S.top == 0)
         return 0;      //栈为空
   e = S.base[S.top-1];
   return 1;
}
//----------------队列---------------- 
void InitSq(Sq &QQ)
{
	QQ.base=(int*)malloc(MAX * sizeof(int));	//S.base=(BiTree*)malloc(MAX*sizeof(BiTree)); 
	if(!QQ.base)
		return ;
	QQ.front=QQ.rear=QQ.tag=0;
}

int Getlen(Sq QQ)
{
	if(!QQ.tag)		//分情况讨论tag为 0，长度肯定为 0； 
		return 0;
	else
	{
		if(QQ.rear==QQ.front)
			return MAX;
		return (QQ.rear-QQ.front+MAX)%MAX;
	}
	
}

int Isempty(Sq QQ)
{
	if(QQ.front==QQ.rear && QQ.tag==0)
		return 1;
	return 0;	
}

void InSq(Sq &QQ,int e)
{

	if (QQ.front == QQ.rear && QQ.tag==1)	//tag与队头队尾必须同时满足 
	{
		printf("%d\n",QQ.tag);
		printf("队列已满\n");
		return ;
	}
	QQ.tag=1;
	//	Q.base=(Type )malloc(MAX * sizeof(Type));						
    QQ.base[QQ.rear] = e;
    QQ.rear =(QQ.rear+1)%MAX;
}
void OutSq(Sq &QQ,int &e)
{
	if(QQ.front == QQ.rear && QQ.tag==0)
	{
		printf("队列已空\n");	
		return;
	}
	e=QQ.base[QQ.front];
	QQ.front=(QQ.front+1)%MAX;
	if(QQ.front == QQ.rear)
		QQ.tag=0;
}

void GetHead(Sq QQ,int e)
{
    if(QQ.front == QQ.rear && QQ.tag==0) return;
    e = QQ.base[QQ.front];
}