(转载)图的深度优先遍历非递归算法

纠结图的深度优先搜索算法好久，非递归算法需要用到栈来记录上一次访问的结果，但是大脑中反应不出来。这里做一个记录：

栈的用处：在这一步执行完成之后，下一步需要用到上一步执行的结果，用栈来实现往往是最有效的。

以下是转载的内容：

深度优先遍历算法的非递归实现需要了解深度优先遍历的执行过程，设计一个栈来模拟递归实现中系统设置的工作栈，算法的伪代码描述为：

 

假设图采用邻接矩阵作为存储结构，具体算法如下：

 

 

[cpp] view plaincopyprint?
  1. 　深度优先遍历算法的非递归实现需要了解深度优先遍历的执行过程，设计一个栈来模拟递归实现中系统设置的工作栈，算法的伪代码描述为：   
  2.   
  3.   
  4. 　　假设图采用邻接矩阵作为存储结构，具体算法如下：  
  5.   
  6.   
  7. <PRE class=cpp name="code">#include<iostream>  
  8. #include <queue>   
  9. using namespace std;  
  10. #define  MAX_NODE 12   
  11. bool visited[MAX_NODE] ;  
  12. int stack[ MAX_NODE] ;  
  13. queue<int> q;  
  14. int Matric[MAX_NODE][MAX_NODE] =  
  15. {  
  16.     {-1,1,1,0,0,0,0,0,0,0,0,0},  
  17.     {1,-1,1,0,1,1,0,0,0,0,0,0},  
  18.     {1,1,-1,1,0,0,0,0,0,0,0,0},  
  19.     {0,0,1,-1,1,0,0,0,0,0,1,1},  
  20.     {0,1,0,1,-1,0,0,0,0,0,0,0},  
  21.     {0,1,0,0,0,-1,0,0,0,0,1,0},  
  22.     {0,0,0,0,0,0,-1,1,1,1,0,0},  
  23.     {0,0,0,0,0,0,1,-1,0,0,0,0},  
  24.     {0,0,0,0,0,0,1,0,-1,1,1,0},  
  25.     {0,0,0,0,0,0,1,0,1,-1,0,1},  
  26.     {0,0,0,1,0,1,0,0,1,0,-1,0},  
  27.     {0,0,0,1,0,0,0,0,0,1,0,-1},   
  28. };  
  29. void DFS( int v)  
  30. {  
  31.     cout << " v"<< v ;  
  32.     int top = -1 ;  
  33.     visited[v] = true ;  
  34.     stack[++top] = v ;  
  35.     while ( top != -1)  
  36.     {  
  37.         v = stack[top] ;  
  38.         for (int i = 0 ; i < MAX_NODE ; i++)  
  39.         {  
  40.             if (Matric[v][i] == 1 &&!visited[i])  
  41.             {  
  42.                 cout << " v" << i ;  
  43.                 visited[i] = true ;  
  44.                 stack[ ++top ] = i ;  
  45.                 break ;  
  46.             }  
  47.         }  
  48.         if( i == MAX_NODE)  
  49.         {  
  50.             top -- ;  
  51.         }  
  52.     }  
  53.       
  54. }  
  55.   
  56.   
  57. void BFS( int v)  
  58. {  
  59.     int node = 0;  
  60.     q.push(v);  
  61.     visited[v] = true;  
  62.     while( !q.empty())  
  63.     {         
  64.         node = q.front();  
  65.         for ( int i = 0; i < MAX_NODE; i++ )  
  66.         {  
  67.             if ( Matric[node][i] == 1 && !visited[i])  
  68.             {  
  69.                 visited[i] = true;  
  70.                 q.push(i);  
  71.             }  
  72.         }  
  73.         cout <<" v" << node;  
  74.         q.pop();  
  75.     }  
  76.       
  77.       
  78. }  
  79. void Init()  
  80. {  
  81.       
  82.     int i = 0;  
  83.     for ( i = 0; i < MAX_NODE; i++)  
  84.     {  
  85.         visited[i] = false;  
  86.     }  
  87. }  
  88. int main()  
  89. {  
  90.     Init();  
  91.     DFS( 1 ) ;  
  92.     cout << endl ;  
  93.     Init();  
  94.     BFS( 1 );  
  95.     cout << endl;  
  96.     Init();  
  97.     DFS( 6 );  
  98.     cout <<endl;  
  99.     return 0 ;  
  100. }</PRE>  
  101. <PRE></PRE>  
  102. <PRE class=cpp name="code"></PRE>  
　深度优先遍历算法的非递归实现需要了解深度优先遍历的执行过程，设计一个栈来模拟递归实现中系统设置的工作栈，算法的伪代码描述为： 


　　假设图采用邻接矩阵作为存储结构，具体算法如下：
[cpp] view plaincopyprint?
  1. #include<iostream>   
  2. #include <queue>   
  3. using namespace std;  
  4. #define  MAX_NODE 12   
  5. bool visited[MAX_NODE] ;  
  6. int stack[ MAX_NODE] ;  
  7. queue<int> q;  
  8. int Matric[MAX_NODE][MAX_NODE] =  
  9. {  
  10.     {-1,1,1,0,0,0,0,0,0,0,0,0},  
  11.     {1,-1,1,0,1,1,0,0,0,0,0,0},  
  12.     {1,1,-1,1,0,0,0,0,0,0,0,0},  
  13.     {0,0,1,-1,1,0,0,0,0,0,1,1},  
  14.     {0,1,0,1,-1,0,0,0,0,0,0,0},  
  15.     {0,1,0,0,0,-1,0,0,0,0,1,0},  
  16.     {0,0,0,0,0,0,-1,1,1,1,0,0},  
  17.     {0,0,0,0,0,0,1,-1,0,0,0,0},  
  18.     {0,0,0,0,0,0,1,0,-1,1,1,0},  
  19.     {0,0,0,0,0,0,1,0,1,-1,0,1},  
  20.     {0,0,0,1,0,1,0,0,1,0,-1,0},  
  21.     {0,0,0,1,0,0,0,0,0,1,0,-1},   
  22. };  
  23. void DFS( int v)  
  24. {  
  25.     cout << " v"<< v ;  
  26.     int top = -1 ;  
  27.     visited[v] = true ;  
  28.     stack[++top] = v ;  
  29.     while ( top != -1)  
  30.     {  
  31.         v = stack[top] ;  
  32.         for (int i = 0 ; i < MAX_NODE ; i++)  
  33.         {  
  34.             if (Matric[v][i] == 1 &&!visited[i])  
  35.             {  
  36.                 cout << " v" << i ;  
  37.                 visited[i] = true ;  
  38.                 stack[ ++top ] = i ;  
  39.                 break ;  
  40.             }  
  41.         }  
  42.         if( i == MAX_NODE)  
  43.         {  
  44.             top -- ;  
  45.         }  
  46.     }  
  47.       
  48. }  
  49.   
  50.   
  51. void BFS( int v)  
  52. {  
  53.     int node = 0;  
  54.     q.push(v);  
  55.     visited[v] = true;  
  56.     while( !q.empty())  
  57.     {         
  58.         node = q.front();  
  59.         for ( int i = 0; i < MAX_NODE; i++ )  
  60.         {  
  61.             if ( Matric[node][i] == 1 && !visited[i])  
  62.             {  
  63.                 visited[i] = true;  
  64.                 q.push(i);  
  65.             }  
  66.         }  
  67.         cout <<" v" << node;  
  68.         q.pop();  
  69.     }  
  70.       
  71.       
  72. }  
  73. void Init()  
  74. {  
  75.       
  76.     int i = 0;  
  77.     for ( i = 0; i < MAX_NODE; i++)  
  78.     {  
  79.         visited[i] = false;  
  80.     }  
  81. }  
  82. int main()  
  83. {  
  84.     Init();  
  85.     DFS( 1 ) ;  
  86.     cout << endl ;  
  87.     Init();  
  88.     BFS( 1 );  
  89.     cout << endl;  
  90.     Init();  
  91.     DFS( 6 );  
  92.     cout <<endl;  
  93.     return 0 ;  
  94. }  


 











            

            
posted @ 
2013-04-23 21:54 
李VS超 
阅读(2196) 
评论(0) 
编辑 
收藏 
举报