代码随想录算法训练营第十三天

LeetCode 144.二叉树的前序遍历

链接

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }

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

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> res;
        if(root == nullptr) {
            return res;
        }
        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;
    }
};

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

LeetCode 145.二叉树的后序遍历

链接

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root, res);
        return res;
    }

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

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

LeetCode 94.二叉树的中序遍历

链接

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

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

LeetCode102. 二叉树的层序遍历

链接

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        int depth = 0;
        order(root, res, depth);
        return res;
    }
    void order(TreeNode* cur, vector<vector<int>>& res, int depth) {
        if(cur == nullptr) {
            return ;
        }
        if(res.size() == depth) {
            res.push_back(vector<int>());
        }
        res[depth].push_back(cur->val);
        order(cur->left, res, depth + 1);
        order(cur->right, res, depth + 1);
    }
};

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