理论基础 —— 二叉树 —— 二叉树的遍历

【递归遍历】

以二叉链表的存储结构为例

1.先序遍历

若二叉树为空，则空操作，否则：先访问根结点，再先序遍历左子树，然后先序遍历右子树

void preOrder(Node *bt){//先序遍历根结点为bt的二叉树的递归算法
    if(bt==NULL)
        return;
    else{
      cout<<bt->data;//输出根节点bt的数据域
      preOrder(bt->lchild);//前序遍历bt的左子树
      preOrder(bt->rchild);//前序遍历bt的右子树
   }
}

2.中序遍历

若二叉树为空，则空操作，否则：先中序遍历左子树，再访问根结点，然后中序遍历右子树

void inOrder(Node *bt){//中序遍历根结点为bt的二叉树的递归算法
    if(bt==NULL)
        return;
    else{
        inOrder(bt->lchild);//中序遍历bt的左子树
        cout<<bt->data;//输出根节点bt的数据域
        inOrder(bt->rchild);//中序遍历bt的右子树
    }
}

3.后序遍历

若二叉树为空，则空操作，否则：先后序遍历左子树，再后序遍历右子树，然后访问根结点

void postOrder(Node *bt){//后序遍历根结点为bt的二叉树的递归算法
    if(bt==NULL)
        return;
    else{
        postOrder(bt->lchild);//后序遍历bt的左子树
        postOrder(bt->rchild);//后序遍历bt的右子树
        cout<<bt->data;//输出根结点bt的数据域
    }
}

4.层序遍历 

从根结点开始，首先将根结点入队，然后从队首取出一个元素，访问该指针所指的结点，若该指针所指的结点左、右孩子非空，则将其左孩子指针、右孩子指针入队，重复上述操作，直至队列为空。

void levelOrder(Node *root){
    queue<Node *> Q;
    if(root)
        Q.push(root);
    while(!Q.empty()){
        root=Q.front();//取队列首结点
	    Q.pop();
        
        cout<<root->data;//访问当前结点
        if(root->lchild)//左子树进队列
            Q.push(root->lchild);
        if(root->rchild) //右子树进队列
            Q.push(root->rchild); 	
    }
}

【非递归遍历】

以二叉链表的存储结构为例

1.先序遍历

借助栈，遇到一个结点，就访问该结点，并把此结点推入栈中，然后遍历它的左子树，遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。

void preOrder(Node *root) {
    stack<Node *>  s;
    while(root!=NULL || !s.empty()) {
        while (root!= NULL){
            cout<<root->data;
            s.push(root);
            root=root->lchild;
        }
        if(!s.empty()) {
            root=s.pop();
            root=root->rchild;
        }
    }
}

2.中序遍历

借助栈，遇到一个结点，就把它推入栈中，并去遍历它的左子树，遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。

void inOrder(Node *root){
    stack<Node * > s;
    while(root!=NULL || !s.empty()) {
        while(root!=NULL){
            s.push(root);
            root=root->lchild;
        }
        if(!s.empty()) {
            root=s.top();
            s.pop();
            cout<<root->data;
            root=root->rchild;
        }
    }
}

3.后序遍历

借助栈，遇到一个结点，把它推入栈中，遍历它的左子树，左子树遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树，遍历遍右子树后才能从栈顶托出该结点并访问。

void postOrder(Node *root) {
    stack<Node *> s;
    Node *cur,*pre=NULL;
    if(root==NULL)
        return;
    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);
        }
    }
}