二叉树的先序、中序、后续、深度、广度遍历

1、二叉树的递归：先序，中序，后序遍历

//树的结构定义
struct TreeNode{
    int data;
    struct TreeNode *lchild,*rchild;
};

void PreOrder(TreeNode *T){
    if(T){
        cout<<T->data<<endl;//先序遍历
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}
void MidOrder(TreeNode *T){
    if(T){
        MidOrder(T->lchild);
        cout<<T->data<<endl;//中序遍历
        MidOrder(T->rchild);
    }
}
void PstOrder(TreeNode *T){
    if(T){
        PstOrder(T->lchild);
        PstOrder(T->rchild);
        cout<<T->data<<endl;//后序遍历
    }
}

非递归方式，先序遍历，中序遍历，后序遍历

• 1)访问结点P，并将结点P入栈;
  2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);
  若不为空，则将P的左孩子置为当前的结点P;
  3)直到P为NULL并且栈为空，则遍历结束。

//先序遍历
void preOrder(TreeNode *root){
    stack<TreeNode*>s;
    TreeNode* p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            cout<<p->data<<"";
            s.push(p);
            p=p->lchild;
        }
        while(!s.empty()){
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}
//中序遍历
void midOrder(TreeNode *root){
    stack<TreeNode*>s;
    TreeNode* p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            s.push(p);
            p=p->lchild;
        }
        while(!s.empty()){
            p=s.top();
            cout<<p->data<<"";
            s.pop();
            p=p->rchild;
        }
    }
}

//后序遍历

• 要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，
  先将其入栈。1、如果P不存在左孩子和右孩子，则可以直接访问它；2、或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。//若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了 每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postOrder(TreeNode* root){
    stack<TreeNode*>s;
    TreeNode* cur;
    TreeNode* pre=NULL;
    s.push(root);
    while(!s.empty()){
        cur=s.top();
        if((cur->lchild==NULL && cur->rchild==NULL)||
        (pre!=NULL &&(pre==cur->lchild || pre==cur->rchild))){
            cout<<cur->data<<"";
            s.pop();
            pre=cur;
        }else{
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)
                s.push(cur->lchild);
        }
    }
}

2、二叉树的深度优先遍历，广度优先遍历

//利用栈，先将右子树压栈再将左子树压栈

深度优先遍历：利用栈

void DepthFirstSearch(TreeNode* root){
    stack<TreeNode*>nodeStack;
    nodeStack.push(root);
    while(!nodeStack.empty()){
        TreeNode* node = nodeStack.top();
        cout<<node->data<<"";
        nodeStack.pop();
        if(node->right)
            nodeStack.push(node->right);
        if(node->left)
            nodeStack.push(node->left);
    }
}

广度优先遍历： 队列

void BreadthFirstSearch(TreeNode* root){
    queue<TreeNode*>nodeQueue;
    nodeQueue.push(root);
    while(!nodeQueue.empty()){
        TreeNode* node = nodeQueue.front();
        cout<<node->data<<"";
        nodeQueue.pop();
        if(node->left)
            nodeQueue.push(node->left);
        if(node->right)
            nodeQueue.push(node->right);
    }
}