深度优先遍历与广度优先遍历（c++二叉树算法实现）

1．深度优先遍历的递归定义

　　假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶点，则另选一个尚未访问的顶点作为新的源点重复上述过程，直至图中所有顶点均已被访问为止。

　　图的深度优先遍历类似于树的前序遍历。采用的搜索方法的特点是尽可能先对纵深方向进行搜索。这种搜索方法称为深度优先搜索(Depth-First Search)。相应地，用此方法遍历图就很自然地称之为图的深度优先遍历

 

2.基本实现思想：

（1）访问顶点v；

（2）从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；

（3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

 

3.伪代码

递归实现

（1）访问顶点v；visited[v]=1；//算法执行前visited[n]=0

（2）w=顶点v的第一个邻接点；

（3）while（w存在）  

           if（w未被访问）

                   从顶点w出发递归执行该算法； 
           w=顶点v的下一个邻接点；

 

非递归实现

 （1）栈S初始化；visited[n]=0；

 （2）访问顶点v；visited[v]=1；顶点v入栈S

 （3）while(栈S非空)

            x=栈S的顶元素(不出栈)；

            if(存在并找到未被访问的x的邻接点w)

                    访问w；visited[w]=1；

                    w进栈;

            else

                     x出栈；

 广度优先遍历

1.广度优先遍历定义

 图的广度优先遍历BFS算法是一个分层搜索的过程，和树的层序遍历算法类同，它也需要一个队列以保持遍历过的顶点顺序，以便按出队的顺序再去访问这些顶点的邻接顶点。 

2.基本实现思想

（1）顶点v入队列。

（2）当队列非空时则继续执行，否则算法结束。

（3）出队列取得队头顶点v；访问顶点v并标记顶点v已被访问。

（4）查找顶点v的第一个邻接顶点col。

（5）若v的邻接顶点col未被访问过的，则col入队列。

（6）继续查找顶点v的另一个新的邻接顶点col，转到步骤（5）。

        直到顶点v的所有未被访问过的邻接点处理完。转到步骤（2）。

广度优先遍历图是以顶点v为起始点，由近至远，依次访问和v有路径相通而且路径长度为1，2，……的顶点。为了使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问，需设置队列存储访问的顶点。

3.伪代码

（1）初始化队列Q；visited[n]=0；

（2）访问顶点v；visited[v]=1；顶点v入队列Q；

（3） while（队列Q非空）   

              v=队列Q的对头元素出队；

              w=顶点v的第一个邻接点；

             while（w存在） 

                     如果w未访问，则访问顶点w；

                     visited[w]=1；

                     顶点w入队列Q；

                     w=顶点v的下一个邻接点。

转自：http://www.cnblogs.com/biyeymyhjob/archive/2012/07/18/2596983.html

递归深度优先遍历：分为先序、中序、后序遍历

1. //前序遍历  
2. void PreOrderTraverse(BiTree T)  
3. {  
4.     if(T){  
5.         printf("%c ",T->ch);  
6.         PreOrderTraverse(T->lchild);  
7.         PreOrderTraverse(T->rchild);  
8.     }  
9. }  
10.   
11. //中序遍历  
12. void InOrderTraverse(BiTree T)  
13. {  
14.     if(T){  
15.         InOrderTraverse(T->lchild);  
16.         printf("%c ",T->ch);  
17.         InOrderTraverse(T->rchild);  
18.     }  
19. }  
20.   
21. //后序遍历  
22. void PostOrderTraverse(BiTree T)  
23. {  
24.     if(T){  
25.         PostOrderTraverse(T->lchild);  
26.         PostOrderTraverse(T->rchild);  
27.         printf("%c ",T->ch);  
28.     }  
29. }

非递归深度优先遍历：是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。先序遍历如下所示，中序和后序同理~

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

//深度优先遍历二叉树void depthFirstSearch(Tree root){      stack<node *= "" > nodeStack;   //使用C++的STL标准模板库      nodeStack.push(root);      Node *node;      while (!nodeStack.empty()){          node = nodeStack.top();          printf (format, node->data);   //遍历根结点          nodeStack.pop();          if (node->rchild){              nodeStack.push(node->rchild);   //先将右子树压栈          }          if (node->lchild){              nodeStack.push(node->lchild);   //再将左子树压栈          }      } } </node>

 

广度优先遍历：是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

//广度优先遍历 void  breadthFirstSearch(Tree root){      queue<node *= "" > nodeQueue;   //使用C++的STL标准模板库      nodeQueue.push(root);      Node *node;      while (!nodeQueue.empty()){          node = nodeQueue.front();          nodeQueue.pop();          printf (format, node->data);          if (node->lchild){              nodeQueue.push(node->lchild);   //先将左子树入队          }          if (node->rchild){              nodeQueue.push(node->rchild);   //再将右子树入队          }      } } </node>

转自：http://www.cnblogs.com/calamus/p/5877758.html