力扣数据结构14天学习计划

力扣144—二叉树的前序遍历（中左右）

力扣144

题意

 

解题思路—递归+非递归

class Solution 
{
public:
    void _preorderTraversal(TreeNode* node,vector<int>& res)
    {
        //递归出口，节点为空就返回
        if(nullptr==node)
            return;
        //单层递归逻辑。
        res.push_back(node->val);//中
        _preorderTraversal(node->left,res);//左
        _preorderTraversal(node->right,res);//右
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        /*
        递归遍历
        vector<int>res;
        if(nullptr==root)
            return res;
        _preorderTraversal(root,res);
        return res;
        */
        
        if(nullptr==root)
            return {};
        vector<int>res;
        stack<TreeNode*>st;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* node=st.top();
            st.pop();
            res.emplace_back(node->val);    //中

            //由于栈的后入先出特性，我们先将右孩子加入栈中，然后再将左孩子加入栈中
            //这样，出栈的时候就左孩子先出栈，达到中左右的效果
            if(nullptr!=node->right)
                st.push(node->right);
            if(nullptr!=node->left)
                st.push(node->left);
        }
        return res;
    }
};

力扣94—二叉树中序遍历（左中右）

解题思路—递归+非递归

class Solution 
{
public:
    void in_order(TreeNode* root,vector<int>&res)
    {
        if(nullptr==root)
            return;
        post_order(root->left,res);//左
        res.emplace_back(root->val);//中
        post_order(root->right,res);    //右
        
    }
    vector<int> inorderTraversal(TreeNode* root) 
    {
        if(nullptr==root)
            return {};
        vector<int>res;

        //递归实现
        //in_order(root,res);

        //非递归实现
        stack<TreeNode*>st;
        while(root||!st.empty())
        {
            while(root) //左。一直往左走，将最左边一只的节点加入栈中
            {
                st.push(root);
                root=root->left;
            }
            root=st.top();  
            st.pop();
            res.emplace_back(root->val);//中
            root=root->right;//右
        }

        return res;
    }
};

力扣145—二叉树的后序遍历（左右中）

题意

解题思路—递归+非递归

 前序遍历是：中左右

后序遍历是：左右中

如果前序改成，中右左，再把中右左的遍历顺序，逆转一下，就是左右中了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution 
{
public:
    void post_order(TreeNode* root,vector<int>& res)
    {
        if(nullptr==root)
            return;
        post_order(root->left,res);//左
        post_order(root->right,res);//右
        res.emplace_back(root->val);//中
    } 
    vector<int> postorderTraversal(TreeNode* root) 
    {
        if(nullptr==root)
            return {};
        vector<int>res;

        //递归
        //post_order(root,res);

        //非递归
        stack<TreeNode*>st;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* node=st.top();
            st.pop();
            res.emplace_back(node->val);//中

            //因为遍历顺序是：中右左，所以要先把左孩子加入栈，再把右孩子加入栈
            //这样出栈的时候，就是右孩子先出栈，达到 中、右、左的遍历顺序
            if(node->left)
                st.push(node->left);
            if(node->right)
                st.push(node->right);
        }
        reverse(res.begin(),res.end());
        return res;
    }
};