二叉树遍历总结

二叉树遍历总结


1，前序遍历递归与非递归解法

1.1 前序遍历递归写法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void pre(TreeNode* root,vector<int>& vec){
        if(root)vec.push_back(root->val);
        if(root->left)pre(root->left,vec);
        if(root->right)pre(root->right,vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL) return result;
        pre(root,result);
        return result;
        
    }
};

1.2 前序遍历非递归写法（利用栈实现）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
  
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL) return result;
        stack<TreeNode*> stk;
		stk.push(root);
		while(!stk.empty()){
			TreeNode* tmp = stk.top();
			stk.pop();
			result.push_back(tmp->val);
			if(tmp->right)stk.push(tmp->right);
			if(tmp->left)stk.push(tmp->left);
		


		}
		return result;
        
    }
};

方法二：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
  
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL) return result;
        stack<TreeNode*> stk;
		stk.push(root);
		result.push_back(root->val);
		while(!stk.empty()){
			TreeNode* tmp = stk.top();
		    if(tmp->left){
		        stk.push(tmp->left);
		        result.push_back(tmp->left->val);
		        tmp->left=NULL;
		    }
		    else if(tmp->right){
		        stk.push(tmp->right);
		        result.push_back(tmp->right->val);
		        tmp->right=NULL;
		    }
		    else{
		        stk.pop();
		    }
		}
		return result;
        
    }
};

2,中序遍历递归与非递归解法
2.1 中序遍历递归写法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void inorder(TreeNode* root,vector<int>& vec){
        if(root->left)inorder(root->left,vec);
		if(root)vec.push_back(root->val);
        if(root->right)inorder(root->right,vec);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        if(root==NULL) return result;
        inorder(root,result);
        return result;
        
    }
};

2.2 中序遍历非递归写法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
		vector<int> result;
		if(root==nullptr)return result;
		stack<TreeNode*> stk;
		stk.push(root);
		while(!stk.empty()){
			TreeNode* p = stk.top();
			if(p->left){
				stk.push(p->left);
				p->left=nullptr;	
			}
			else{
				result.push_back(p->val);
			    stk.pop();
				if(p->right)
					stk.push(p->right);
			}


		}
		return result;
    }
};

3,后续遍历的递归与非递归解法
3.1 后序遍历的递归解法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void post(TreeNode* root,vector<int>& vec)
    {
        if(root->left)post(root->left,vec);
        if(root->right)post(root->right,vec);
        vec.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
       vector<int> result;
       if(root==NULL) return result;
       post(root,result);
       return result;
        
        
    }
};

3.2 后续遍历的非递归解法
思路：前序遍历是root-left-right,后续遍历是left-right-root,通过修改非递归前序遍历的代码，使得遍历结构为root-right-left,然后将结果reverse一下即可以得到后续遍历的非递归结果

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        stack<TreeNode*> nodeStack;
        vector<int> result;
        //base case
        if(root==NULL)
        return result;
        nodeStack.push(root);
    while(!nodeStack.empty())
    {
        TreeNode* node= nodeStack.top();  
        result.push_back(node->val);
        nodeStack.pop();
        if(node->left)
        nodeStack.push(node->left);
        if(node->right)
        nodeStack.push(node->right);
    }
     reverse(result.begin(),result.end());
     return result;
    }
};

解法二，利用per指针与cur指针遍历二叉树

#include <stack>

using namespace std;

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector <int> res;
        if (!root) return res;

        stack<TreeNode*> s;
        TreeNode* prev = nullptr;
        s.push(root);

        while (!s.empty())
        {
            TreeNode* cur = s.top();

            //taking into account that if previous element coming from a subtree then it is either direct left or right child
            if (cur->right && cur->right == prev || !cur->right && cur->left == prev || !cur->left && !cur->right)
            {
                s.pop();
                res.push_back(cur->val);
                prev = cur;
                continue;
            }

            if (cur->right) s.push(cur->right);
            if (cur->left) s.push(cur->left);
        }

        return res;        
    }
};

方法三：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
      vector<int> result;
      stack<TreeNode*> stk;
      if(root==NULL) return result;
      TreeNode* cur=root,*prev=NULL;
      while(cur||!stk.empty())
      {
          if(cur){    //走到最左边
              stk.push(cur);
              cur=cur->left;
          }
          else{
               cur = stk.top();
              if(cur->right&&cur->right!=prev){   //如果右子树存在，且没有被访问过
                  cur=cur->right;//转向右边
                  stk.push(cur);//压入栈
                  cur=cur->left;//再走到最左
              }
              else{   //否则弹出结点
                  stk.pop();
                  result.push_back(cur->val);
                  prev=cur; //记录最近访问过的结点
                  cur=NULL;  //设置当前结点已经访问过
              }
              
              
          }
        
      }
     
     return result;
    }
};