二叉树刷题

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

NC15二叉树的层序遍历

链接

class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode* root) {
        TreeNode* ptr = root;
        vector<vector<int>> ans;
        if(ptr == nullptr)
            return ans;
        queue<TreeNode*> q;   //定义一个队列用来保存每层的元素
        q.push(ptr);
        while(!q.empty())
        {
            int size = q.size();   //记录队列中的元素个数就是要遍历的次数
            ans.push_back(vector<int>());  
            for(int i = 0;i < size; i++){
                ptr = q.front();q.pop(); //出队列
                
                ans.back().push_back(ptr->val);    //关键步骤
                
                if(ptr->left != nullptr)
                    q.push(ptr->left);
                if(ptr->right != nullptr)
                    q.push(ptr->right);
            }
        }
        return ans;
    }
};

NC161 二叉树的中序遍历

链接

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        // write code here
        vector<int> ans;
        if(root == nullptr) return ans;
        TreeNode* ptr = root;
        stack<TreeNode*> st;
        while(ptr != nullptr || !st.empty()){
            while(ptr != nullptr){
                st.push(ptr);
                ptr = ptr->left;
            }
            ptr = st.top();st.pop();
            ans.push_back(ptr->val);
            ptr = ptr->right;
        }
        return ans;
    }
};

LC145 二叉树的后序遍历

链接

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root == nullptr) return ans;
        stack<TreeNode*> st;
        TreeNode* ptr = root;
        TreeNode* tag = nullptr;
        while(!st.empty() || ptr != nullptr){
            while(ptr != nullptr){
                st.push(ptr);
                ptr = ptr->left;
            }
            ptr = st.top();st.pop();
            if(ptr->right == nullptr || tag == ptr->right){
                ans.push_back(ptr->val);
                tag = ptr;
                ptr = nullptr;    //这个必须置为空，不然又要陷入上面的循环
            } 
            else{
                st.push(ptr);
                ptr = ptr->right;
            }
        }
        return ans;
    }
};

LC144 二叉树的前序遍历

链接

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

NC45 实现二叉树先序，中序和后序遍历

链接

class Solution {
public:
    void inOrder(TreeNode* root,vector<vector<int>>& res){
        res.push_back(vector<int>());
        TreeNode* ptr = root;
        stack<TreeNode*> st;
        while(ptr != nullptr || !st.empty()){
            while(ptr != nullptr){
                st.push(ptr);
                ptr = ptr->left;
            }
            ptr = st.top();st.pop();
            res.back().push_back(ptr->val);
            ptr = ptr->right;
        }
    }
    void preOrder(TreeNode* root,vector<vector<int>>& res){
        res.push_back(vector<int>());
        TreeNode* ptr = root;
        stack<TreeNode*> st;
        st.push(ptr);
        while(!st.empty()){
            ptr = st.top();st.pop();
            res.back().push_back(ptr->val);
            if(ptr->right != nullptr)
                st.push(ptr->right);
            if(ptr->left != nullptr)
                st.push(ptr->left);
        }
    }
    void postOrder(TreeNode* root,vector<vector<int>>& res){
         res.push_back(vector<int>());
        TreeNode* ptr = root;
        stack<TreeNode*> st;
        TreeNode* flg = nullptr;
        while(!st.empty() || ptr != nullptr){
            while(ptr != nullptr){
                st.push(ptr);
                ptr = ptr->left;
            }
            ptr = st.top();st.pop();
            if(ptr->right == nullptr || flg == ptr->right){
                res.back().push_back(ptr->val);
                flg = ptr;
                ptr = nullptr;
            }
            else{
                st.push(ptr);
                ptr = ptr->right;
            }
        }
    }
    vector<vector<int> > threeOrders(TreeNode* root) {
        vector<vector<int>> res;
        if(root == nullptr) return res;
        preOrder(root,res);
        inOrder(root, res);
        postOrder(root, res);
        return res;
    }
};