【数据结构】（邻接矩阵 | 图 | DFS）邻接矩阵深度遍历图

#include < iostream >
using namespace std;

#define NUM 6

// 定义图 
typedef struct{

	int a[NUM][NUM]; // 表示点之间的关系 
	int vex[NUM];  // 各点存的信息 
}MGragh;

// 图的初始化 
void initGragh(MGragh &G, int w[][NUM], int v[])
{

	for(int i=0;i<NUM;i++){   //每个结点赋值!! 
	    G.vex[i] = v[i];
	}  
	for(int i=0;i<NUM;i++){
		for(int j=0;j<NUM;j++){
			G.a[i][j] = w[i][j];
		}
	}	
}

// 定义栈 
typedef struct{

	int data[NUM];
    int top;
	int stacksize;	
}stack;

// 建栈 
void initstack(stack &s)
{

	s.top = -1;
	s.stacksize = NUM;
}

// 判空
int emptystack(stack s)
{

	if(s.top == -1)
		return 1;
	else 
	    return 0;
} 

// 入栈
void push(stack &s,int e)
{

	if(s.top == s.stacksize-1){
		cout<<"the stack is full"<<endl;
		return;
	}
	s.data[++s.top] = e;
} 

// 出栈
void pop(stack &s,int &e)
{

	if(emptystack(s)){
		cout<<"the stack is empty"<<endl;
		return;
	}
	e = s.data[s.top--];
} 

void DFS(MGragh &G,int v)  // *output 实现数据双向传递 
{

	stack s;  // 函数里建栈 
	initstack(s); 
	int visit[NUM] = {0};  // 访问标志 
	int output[NUM];  // 存储访问下标序列 
	int p,i,j;
	
	p = v-1;    // p 为初始遍历结点的下标
	output[0] = p;  // 存入初始遍历结点的下标p
	visit[p] = 1;  // 置为 1 
	push(s,p);
	
	i = 1;  // 已遍历的结点数 
	while(1){  // 结点未遍历完 
		for(j=0;j<NUM;j++){   // 寻找临接点，且未被遍历 
			if(G.a[p][j]==1 && visit[j]==0){
				break;
			}
		}
		if(j<NUM){   // 找到邻接点 
			p = j;  // p 记录下标 
		    visit[p] = 1;
			output[i++] = p;
		    push(s,p);
		}
		else  // 即 j = NUM 
		{  // 没有邻接点，回溯 
			if(!emptystack(s)){
				pop(s,p);
				if(emptystack(s))
				    break;
				pop(s,p);
			    push(s,p);
			}	
			else 
			    break;
		}
	} 
	
	for(int i=0;i<NUM;i++){
    	cout<<G.vex[output[i]]<<" ";
    }
    cout<<endl;
}

int main()
{

	int a[][NUM] = { 0, 1, 1, 1, 0, 0,
                     1, 0, 0, 0, 1, 0,
                     1, 0, 0, 0, 1, 0,
                     1, 0, 0, 0, 0, 1,
                     0, 1, 1, 0, 0, 0,
                     0, 0, 0, 1, 0, 0}; 
    int b[NUM][NUM]= { 0,1,1,1,1,1,
				       1,0,0,0,0,0,
					   1,0,0,0,0,0,
			    	   1,0,0,0,0,0,
					   1,0,0,0,0,0,
					   1,0,0,0,0,0 };
					   
    int v[NUM] = {1,2,3,4,5,6};
    MGragh G;
    initGragh(G,a,v);
    DFS(G,4);

    return 0;
}