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

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

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

    以下是转载的内容：

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

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

    [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. }  
    

     
    

    


    

    
    
          
    • 

          
  • 

            相关阅读:
    
            
              選定下拉列表的方法 
                
    JAVA学习路线 
                
    封装 
                
    重写（Overriding） 
                
    java内存泄露 
                
    学习实例.文章管理.文章类.Article.java 
                
    方法重载 
                
    学习实例.文章管理.分页查询类.Page.java 
                
    学习实例.文章管理.目标与经验总结 
                
    Java多线程1 
                
                    
          
    • 
          
  • 
            原文地址：https://www.cnblogs.com/fistao/p/3038996.html
          
    • 

        

      



      
      

        

        

      

    

  


  

  
Copyright © 2020-2023 
  润新知