二叉树遍历

    这篇文章对二叉树的遍历进行总结，主要是前序遍历、中序遍历、后序遍历的递归和非递归写法。

    遍历即将树的所有结点访问且仅访问一次。按照根节点位置的不同主要分为前序遍历，中序遍历，后序遍历。

1. 前序遍历

 步骤：

1. 访问根节点；
2. 前序遍历左子树；
3. 前序遍历右子树；

递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void Pre_Order(Node *root){
    if(root != NULL){
        cout<<root->data<<endl; //1.访问根节点
        Pre_Order(root->left);  //2.前序遍历左子树
        Pre_Order(root->right); //3.前序遍历右子树
    }
}

非递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void Pre_Order(Node *root)
{
    stack<Node*> s;
    if(root != NULL){
        s.push(root);
    }
    while (!s.empty())
    {
        Node *p = s.top();
        s.pop();
        if (p != NULL)
        {
            cout << p->data <<endl;
            if(p->right != NULL)
                s.push(p->right);   //先放右子树，因为是栈，先放进去的后访问
            if(p->left != NULL)
                s.push(p->left);
       }
    }
}

2. 中序遍历

步骤：

1. 中序遍历左子树；
2. 访问根节点；
3. 中序遍历右子树；

递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void In_Order(Node *root)
{
    if(root != NULL)
    {
        In_Order(root->left);
        cout << root->data <<endl;
        In_Order(root->right);
    }
}

非递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void In_Order(Node *root)
{
    stack<Node *> s;
    while (root != NULL || !s.empty())
    {
        if (root != NULL)   //1.中序遍历遍历左子树
        {
            s.push(root);
            root = root->left;
        }
        else
        {
            root = s.top();  //2.访问根节点
            cout << root->data <<endl;
            s.pop();
            root = root->right;//3.中序遍历右子树
        }
    }
}

3. 后续遍历

步骤：

1. 后序遍历左子树；
2. 后序遍历右子树；
3. 访问根节点；

递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void Post_Order(Node *root)
{
    if(root != NULL)
    {
        Post_Order(root->left);
        Post_Order(root->right);
        cout << root->data <<endl;
    }
}

非递归代码：

    后序遍历的非递归代码比较难理解，主要是访问根节点的时机（1）当右子树为空（2）当前一个访问过的节点是当前要访问节点的右子树的时候。这里设pos为前一个访问过的节点。代码如下所示：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void Post_Order(Node* root){
    Node* curt = root;
    Node* pos = NULL;
    stack<Node*> s;
    while (curt || !s.empty())
    {
        while (curt)
        {
            s.push(curt);
            curt = curt->left;
        }
        Node* top = s.top();
        if(top->right == NULL || top->right == pos){
	    cout<<top->data<<endl;
	    pos = top;
	    s.pop();
        }else{
	    curt = top->right;
        }
    }
}

    后序遍历还可以用两个栈来实现，第一个栈存的访问顺序是根节点、右子树、左子树。然后第二个栈把第一个栈的顺序记下来，然后输出就可以了。

两个栈的非递归代码：

/*
struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};
*/
void Post_Order(Node *root){
    if(!root) return;
    stack<Node*> s, Output;
    s.push(root);
    while(!s.empty())
    {
        Node *curt = s.top();
        Output.push(curt);
        s.pop();
        if(curt->left)
            s.push(curt->left);
        if(curt->right)
            s.push(curt->right);
    }
    while(!Output.empty())
    {
        cout << Output.top()->data <<endl;
        Output.pop();
    }
}