二叉树先序遍历，中序遍历、后序遍历的递归/非递归方法总结

二叉树的三种遍历的递归和非递归的方法总结

1. 先序遍历

访问顺序：先访问根节点，再访问左孩子，最后访问右孩子
递归方法：很简单，这里不在详细介绍

public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root == NULL)
            return result;
        result.push_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        return result;
    }
private:
    vector<int>result;

非递归方法

• 方法1
  根据先序遍历访问顺序，有限访问根节点，再分别访问左孩子和右孩子，对于任意结点，其都可以看做为根结点，因此可以直接访问，访问完之后，若其左孩子不空，按照相同的规则访问它的左子树；当访问完其左子树时，再访问它的右子树。对任意结点P：
  1>.访问结点P，并将结点P入栈；
  2>.判断结点P的左孩子是否为空，若不为空，则将P的左孩子置为当前的节点P；若为空，则取栈顶节点（注意并非访问栈顶结点）并进行出栈操作，并将栈顶结点的右孩子置为当前的节点P；
  贴出代码如下：

    vector<int> preorderTraversal(TreeNode* root){
        vector<int> result;
        stack<TreeNode*> s;
        TreeNode* p=root;
        while(p || !s.empty()){
            while(p){
                result.push_back(p->val);
                s.push(p);
                p=p->left;
            }
            if(!s.empty()){
                p=s.top();
                s.pop();
                p=p->right;
            }
        }
        return result;
    }

• 方法2
  1>.先定义一个栈,把二叉树的根结点入栈
  2>.栈顶出栈并访问,出栈的同时判断它是否有左右孩子,要有则入栈.注:要是左右孩子都存在则先右孩子入栈 遵循后进先出原则。
  3>.最后在栈不为空的条件下一直循环执行步骤2
  贴出代码如下：

    vector<int> preorderTraversal(TreeNode* root){
        vector<int>result;
        if(root == NULL)
            return result;
        stack<TreeNode*>s;
        s.push(root);
        while(!s.empty()){
            TreeNode* p = s.top();
            s.pop();
            result.push_back(p->val);
            if(p->right)
                s.push(p->right);
            if(p->left)
                s.push(p->left);
        }
        return result;
    }  

2. 中序遍历

访问顺序：先访问左孩子，再访问根节点，最后访问右孩子
递归方法：不再介绍

public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == NULL)
            return result;
        inorderTraversal(root->left);
        result.push_back(root->val);
        inorderTraversal(root->right);
        return result;
    }
private:
    vector<int>result;

非递归方法

• 方法（类似上面的先序遍历，仅仅只是访问语句的位置不同）
  根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。对任意借点P处理如下
  1>. 若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理
  2>.若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
  3>.直到P为NULL并且栈为空则遍历结束。

    vector<int> inorderTraversal(TreeNode* root){
        vector<int> result;
        stack<TreeNode*> s;
        TreeNode* p=root;
        while(p || !s.empty()){
            while(p){
                s.push(p);
                p=p->left;
            }
            if(!s.empty()){
                p=s.top();
                result.push_back(p->val);
                s.pop();
                p=p->right;
            }
        }
        return result;
    }

3. 后序遍历

访问顺序：先访问左孩子，再访问右孩子，最后访问根节点
递归方法：不再介绍

public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == NULL)
            return result;
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        result.push_back(root->val);
        return result;
    }
private:
    vector<int>result;

非递归方法

• 方法1
  要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任意结点cur，可以分情况讨论
  1>. cur如果是叶子节点，直接输出
  2>. cur如果有孩子，且孩子没有被访问过，则按照右孩子，左孩子的顺序依次入栈
  3>. cur如果有孩子，而且孩子都已经访问过，则访问cur节点
  如何来表示出p的孩是否都已经访问过了呢？
  最暴力的方法就是对每个节点的状态进行保存，这么做显然是可以的，但是空间复杂度太大了。
  我们可以保存最后一个访问的节点last，如果满足(cur->right==NULL && pre ==cur->left) || pre=cur->right),那么显然cur的孩子都访问过了，接下来可以访问cur

    vector<int> postorderTraversal(TreeNode* root){
      vector<int> result;
      if(root == NULL)
            return result; 
      stack<TreeNode*> s;
      TreeNode *cur;                      //当前结点 
      TreeNode *pre=root;                 //前一次访问的结点 
      s.push(root);
      while(!s.empty())
      {
         cur=s.top();
         if( (cur->left==NULL && cur->right==NULL) || (cur->right==NULL && pre==cur->left) || (pre == cur->right))
         {
             result.push_back(cur->val);
             s.pop();
             pre=cur; 
         }
         else
         {
             if(cur->right!=NULL)
                 s.push(cur->right);
             if(cur->left!=NULL)    
                 s.push(cur->left);
         }
       }
        return result;
    }

• 方法2
  其实我们希望栈中保存的从顶部依次是root->left, root->right, root，当符合上面提到的条件时，就进行出栈操作。有一种巧妙的方法可以做到，先上代码

vector<int> postOrder(TreeNode *root)
{
    vector<int> result;
    if(root == NULL) 
    	return result;
    TreeNode *p = root;
    stack<TreeNode *> s;
    s.push(p);
    s.push(p);
    while(!s.empty())
    {
        p = s.top(); 
        s.pop();
        if(!s.empty() && p==s.top())
        {
            if(p->right) {
			     s.push(p->right);
            	 s.push(p->right);
			}

            if(p->left) {
            	s.push(p->left);
            	s.push(p->left);
            }
        }
        else
            result.push_back(p->val);
    }
    return result;
}

对于每个节点，都压入两遍，在循环体中，每次弹出一个节点赋给p，如果p仍然等于栈的头结点，说明p的孩子们还没有被操作过，应该把它的孩子们加入栈中，否则，访问p。也就是说，第一次弹出，将p的孩子压入栈中，第二次弹出，访问p。