代码随想录算法训练营第十二天 144.二叉树的前序遍历 94.二叉树的中序遍历 145.二叉树的后序遍历

最新推荐文章于 2024-10-11 12:01:25 发布

ryansssss

最新推荐文章于 2024-10-11 12:01:25 发布

阅读量40

点赞数

文章标签：算法数据结构

本文链接：https://blog.csdn.net/ryansssss/article/details/134038840

版权

文档链接1：代码随想录 (programmercarl.com)

文档链接2：代码随想录 (programmercarl.com)

递归写法：实际上，不论前序中序还是后序遍历，都属于深度优先遍历。使用递归代码来实现前中后序遍历的时候，每递归一层都相当于树向下遍历了一层，当遍历到空节点的时候就返回，以结束递归。

144.二叉树的前序遍历

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(result,root);
        return result;
    }

    void traversal(vector<int> &result,TreeNode* cur){
        if(cur == nullptr){
            return;
        }
        result.push_back(cur->val);
        traversal(result,cur->left);
        traversal(result,cur->right);
    }
};

94.二叉树的中序遍历

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(result,root);
        return result;
    }

    void traversal(vector<int> &result,TreeNode* cur){
        if(cur == nullptr){
            return;
        }
        traversal(result,cur->left);
        result.push_back(cur->val);
        traversal(result,cur->right);
    }
};

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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(result,root);
        return result;
    }

     void traversal(vector<int> &result,TreeNode* cur){
        if(cur == nullptr){
            return;
        }
        traversal(result,cur->left);
        traversal(result,cur->right);
        result.push_back(cur->val);
    }
};

非递归/迭代写法：前序遍历的遍历顺序和元素的处理顺序相一致，就是说，前序遍历遍历到那个节点，那个节点就出栈，并把左右孩子入栈。后序遍历可以由前序遍历的遍历序列得到，先把中右左，变成中左右（步骤），这样才能得到序列中右左，再把得到的序列倒置，就变成了左右中的后序遍历序列。中序遍历的写法与上面两种写法不同，因为中序遍历的顺序和处理的顺序没有关系，所以要用另外一个逻辑来处理，先不断遍历左子树直到左子树为空，然后在栈内弹出栈顶节点并访问该节点的右子树。

144.二叉树的前序遍历

/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == nullptr)return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* cur = st.top();
            st.pop();
            if(cur == nullptr)continue;
            result.push_back(cur->val);
            if(cur->right != nullptr)st.push(cur->right);
            if(cur->left != nullptr)st.push(cur->left);
        }
        return result;    
    }

};

94.二叉树的中序遍历

/**
 * 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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur!=nullptr || !st.empty()){
            if(cur != nullptr){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

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:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if(root == nullptr)return result;
        st.push(root);
        while(!st.empty()){
            TreeNode* cur = st.top();
            st.pop();
            if(cur == nullptr)continue;
            result.push_back(cur->val);
            if(cur->left != nullptr)st.push(cur->left);
            if(cur->right != nullptr)st.push(cur->right);
        }
        reverse(result.begin(),result.end());
        return result;    
    }
};

当然迭代方法也是可以统一化的，就像递归法，只需要改变遍历的顺序，这就要求在待处理的节点前插入标志节点。