leetcode刷题31——二叉树的遍历系列

1.二叉树的前序遍历
给你二叉树的根节点 root ，返回它节点值的前 遍历。
递归解法：

class Solution {
public:
    vector<int> ans;
    vector<int> preorderTraversal(TreeNode* root) {
    	if(!root)   return {};
        perorder(root);
        return ans;
    }
    void perorder(TreeNode* root){
        if(!root)   return;
        ans.push_back(root->val);
        perorder(root->left);
        perorder(root->right);
    }
};

迭代解法：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
   	 	if(!root)   return {};
        vector<int> v;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty())
        {
            TreeNode* node=s.top();
            s.pop();
            if(!node) continue;
            v.push_back(node->val);
            s.push(node->right);
            s.push(node->left);     
        }
        return v;
    }
};

或者：
1.对于节点node，只要左子树不为空，就一直向左访问，并将访问的节点压栈。
2.当左子树为空时，另node指向栈顶元素的右节点并弹栈，执行步骤1。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(!root)   return {};
        vector<int> v;
        stack<TreeNode*> s;
        TreeNode* node=root;
        while(node||!s.empty())
        {
            while(node)
            {
                s.push(node);
                v.push_back(node->val);
                node=node->left;
            }
            if(!s.empty())
            {
                node=s.top();
                s.pop();
                node=node->right;
            }
        }        
        return v;
    }

2.二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的中序遍历。
递归解法：

class Solution {
public:
    vector<int> ans;  
    vector<int> inorderTraversal(TreeNode* root) {
   		if(!root)   return {};
        midorder(root);
        return ans;
    }
    void midorder(TreeNode* root)
    {
        if(!root) return;
        midorder(root->left);
        ans.push_back(root->val);
        midorder(root->right);
    }
};

迭代解法：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> v;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty())
        {
            TreeNode *node;
            while(node=s.top())
            	s.push(node->left);
            s.pop();
            if(!s.empty())
            {
                node = s.top();
                s.pop();
                v.push_back(node->val);
                s.push(node->right);
            }
        }
        return v;
    }
};

或者：
1.对于节点node，只要左子树不为空，就一直向左压栈（但不访问）
2.当左子树为空时，访问栈顶元素，并另node指向栈顶元素的右子树，弹栈，执行步骤1。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(!root)   return {};
        vector<int> v;
        stack<TreeNode*> s;
        TreeNode* node=root;
        while(node||!s.empty())
        {
            while(node)
            {
                s.push(node);
                node=node->left;
            }
            if(!s.empty())
            {
                node=s.top();
                v.push_back(node->val);
                s.pop();
                node=node->right;
            }
        }     
        return v;
    }

3.二叉树的后序遍历
给定一个二叉树的根节点 root ，返回它的后序遍历。
递归解法：

class Solution {
public:
    vector<int> ans;  
    vector<int> postorderTraversal(TreeNode* root) {
    	if(!root)   return {};
        postorder(root);
        return ans;
    }
    void postorder(TreeNode* root)
    {
        if(!root) return;
        postorder(root->left);
        postorder(root->right);
        ans.push_back(root->val);
    }
};

迭代解法：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if(!root)   return {};
        vector<int> v;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty())
        {
            TreeNode* node=s.top();
            s.pop();
            if(!node) continue;
            v.push_back(node->val);
            s.push(node->left);
            s.push(node->right);     
        }
        reverse(v.begin(),v.end());
        return v;
    }
};