面试算法二叉树篇（1）

1.实现二叉树的先序、中序和后序遍历

LeetCode 144. 二叉树的前序遍历

//递归
class Solution {
public:
    void preorder(TreeNode* root, vector<int>& v){
        if(root == nullptr){
            return;
        }
        v.push_back(root->val);
        preorder(root->left, v);
        preorder(root->right,v);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> v;
        if(root == nullptr) return v;

        preorder(root, v);
        return v;
    }
};
//迭代
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;
        s.push(root);
        while(root != nullptr && s.size()){
            res.push_back(s.top()->val);
            auto temp = s.top();
            s.pop();
            if(temp->right != nullptr) s.push(temp->right);
            if(temp->left != nullptr) s.push(temp->left);
        }
        return res;
    }
};

LeetCode 94. 二叉树的中序遍历

//递归
class Solution {
public:
    void inorder(TreeNode* root, vector<int>& v){
        if(root == nullptr) return;
        inorder(root->left, v);
        v.push_back(root->val);
        inorder(root->right, v);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> v;
        if(root == nullptr) return v;

        inorder(root, v);
        return v;
    }
};
//迭代
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> s;

        while(root!=nullptr || s.size()){
            while(root != nullptr){
                s.push(root);
                root = root->left;
            }
            auto temp = s.top();
            res.push_back(temp->val);
            s.pop();
            root = temp->right;
        }
        return res;
    }
};

LeetCode 145. 二叉树的后序遍历

// 迭代
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;
        stack<TreeNode*> s;
        TreeNode* pre = nullptr;
        
        while(root || s.size()){
            while(root != nullptr){
                s.push(root);
                root = root->left;
            }
            root = s.top();
            s.pop();
            if(!root->right || root->right == pre){
                //对已经加入数列的右节点做标记  
                res.push_back(root->val);
                pre = root;
                root = nullptr;
            }else{
                s.push(root);
                root = root->right;
            }
        }
        return res;
    }
};

附:一个万能迭代，更接近递归思想

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

2.二叉树的层序遍历

LeetCode 102. 二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> queue;
        vector<vector<int>> v;       
        queue.push(root);

        while(root && queue.size()){
            vector<int> v1;
            for(int i = queue.size(); i > 0; i--){
                v1.push_back(queue.front()->val);
                if(queue.front()->left) queue.push(queue.front()->left);
                if(queue.front()->right) queue.push(queue.front()->right);
                queue.pop();            
            }
            v.push_back(v1);
        }
        return v;
    }
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> v;
        vector<int> v1;
        queue<TreeNode*> q;
        if(root !=NULL) q.push(root);
        int k = 0;

        while(q.size()){
            for(int i = q.size(); i > 0; i--){
                v1.push_back(q.front()->val);
                if(q.front()->left != NULL) q.push(q.front()->left);
                if(q.front()->right != NULL) q.push(q.front()->right);
                q.pop();
            }
            if(k%2 == 0){
                v.push_back(v1);
            }else{
                vector<int> v2;
                while(v1.size()){
                    v2.push_back(v1.back());
                    v1.pop_back();
                }
                v.push_back(v2);
            }            
            v1.clear();
            k++;
        }  
        return v;
    }
};
// 利用双向队列
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> v;
        deque<TreeNode*> deq;

        int k = 0;
        deq.push_back(root);
        while(root && deq.size()){
            vector<int> v1;
            if(k % 2 == 0){
                for(int i = deq.size(); i > 0; i--){
                    v1.push_back(deq.front()->val);
                    if(deq.front()->left) deq.push_back(deq.front()->left);
                    if(deq.front()->right) deq.push_back(deq.front()->right);
                    deq.pop_front();
                }
            }else{
                for(int i = deq.size(); i > 0; i--){
                    v1.push_back(deq.back()->val);
                    if(deq.back()->right) deq.push_front(deq.back()->right);
                    if(deq.back()->left) deq.push_front(deq.back()->left);
                    deq.pop_back();
                }
            }
            k++;
            v.push_back(v1);
        }
        return v;
    }
};