二叉树的DFS/BFS

广度优先遍历

    BFS，也就是层次遍历，相当于前序。需要借助一个队列，现将二叉树的根节点入队，然后出队，访问该节点，如果它有左子树，则将左子树根节点入队；如果有右子树，则将右子树根节点入队。然后出队，对出队节点访问，如此反复，直到队列为空。

1. void LevelOrder(BiTree root)
2. {
3.      InitQueue(Q);               //初始化队列
4.     
5.      BiTree p;
6.      EnQueue(Q,root);            //将根节点入队
7.      while(!IsEmpty(Q))          //队列不空循环
8.      {
9.          DeQueue(Q,p);          //访问p所指向节点
10.          visit(p);
11.         if(p->lchild != NULL)
12.               EnQueue(Q,p->lchild);         //左子树不空则左子树入队
13.         if(p->rchild != NULL)
14.               EnQueue(Q，p->rchild);
15.       }
16. }

深度优先遍历

     DFS，遍历了根节点后，就开始遍历左子树，所以右子树肯定最后遍历。我们利用栈的性质，所以先将右子树压栈，然后在对左子树压栈。此时，左子树节点是在top上的，所以可以先去遍历左子树。

1. void DepthFirstTravel(Tree *root)  
2. {  
3.     stack<Tree *> s;  
4.      s.push(root);           //根节点入栈
5.     while(!s.empty())  
6.     {  
7.         root = s.top();                //读取根节点
8.         cout << root->data << " ";  
9.             s.pop();                   //根节点出栈
10. 
    
11.         if(root->rchild != NULL)  
12.         {  
13.             s.push(root->rchild);           //先右
14.         }  
15.         if(root->lchild != NULL)  
16.         {  
17.             s.push(root->lchild);           //再左
18.         }  
19.   
20.     }  
21. }  

==================================

栈空： s.top ==  -1

栈满： s.top == MaxSize -1

入栈： s.data[++s.top] = x ;     //指针先加1，再入栈

出栈： x = s.data[s.top--];        //先出栈，指针再减1

队空：Q.front == Q.rear

队满：（Q.rear+1）%MaxSize == Q.front

队列中元素：(Q.rear - Q.front + Maxsize)%MaxSize