代码随想录算法训练营第十二天| 二叉树的递归遍历、迭代遍历、统一迭代法、层序遍历

二叉树基础

遍历方式

深度遍历

利用递归或堆栈

1. 前序遍历
2. 中序遍历
3. 后序遍历

层序遍历

利用列表

二叉树数据结构

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二叉树的递归遍历

写递归函数时需要考虑3个注意事项：

1. 递归函数的参数与返回值（在二叉树遍历中，参数一般是树节点和存放结果的数组，返回值是void）
2. 确定终止条件
3. 确定单层递归的逻辑

144.二叉树的前序遍历

class Solution {
public:
    void traverse(TreeNode* cur, vector<int>& res) {
        if (cur == nullptr) 
            return;
        res.push_back(cur->val);
        traverse(cur->left, res);
        traverse(cur->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

145.二叉树的后序遍历

class Solution {
public:
    void traverse(TreeNode* cur, vector<int>& res) {
        if (cur == nullptr)
            return;
        traverse(cur->left, res);
        traverse(cur->right, res);
        res.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

94.二叉树的中序遍历

class Solution {
public:
    void traverse(TreeNode* cur, vector<int>& res) {
        if (cur == nullptr)
            return;
        traverse(cur->left, res);
        res.push_back(cur->val);
        traverse(cur->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

二叉树的迭代遍历

144.二叉树的前序遍历

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


        return res;
    }
};

145.二叉树的后序遍历

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

        reverse(res.begin(), res.end());
        return res;
    }
};

94.二叉树的中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *curr = root;
        stack<TreeNode*> st;

        while (curr || !st.empty()) {
            if (curr) {
                st.push(curr);
                curr = curr->left;
            }
            else {
                TreeNode *node = st.top();
                st.pop();
                res.push_back(node->val);
                curr = node->right;
            }
        }
        return res;
    }
};

二叉树的统一迭代法

144.二叉树的前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;

        if (root)
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();

                if (node->right)
                    st.push(node->right);

                if (node->left)
                    st.push(node->left);
                st.push(node);
                st.push(nullptr);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

94.二叉树的中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;

        if (root) 
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                if (node->right)
                    st.push(node->right);
                st.push(node);
                st.push(nullptr);
                if (node->left)
                    st.push(node->left);
            }
            else {
                st.pop();
                node = st.top();
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

145.二叉树的后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;

        if (root) 
            st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node) {
                st.pop();
                st.push(node);
                st.push(nullptr);
                
                if (node->right)
                    st.push(node->right);

                

                if (node->left)
                    st.push(node->left);
            }
            else {
                st.pop();
                node = st.top();
                st.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if (root)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> v;
            while(size--) {
                TreeNode* node = que.front();
                v.push_back(node->val);
                que.pop();
                if (node->left) 
                    que.push(node->left);
                if (node->right)
                    que.push(node->right);
            }
            res.push_back(v);
        }
        return res;
    }
};