二叉树 常见面试题 C++实现

待续

1. 前序遍历的非递归实现

LeetCode 144

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> vec;
        if(root==nullptr){
            return vec;
        }
        stack<TreeNode*>s;
        s.push(root);
        while(!s.empty()){
            //打印当前节点
            TreeNode* node = s.top();
            vec.push_back(node->val);
            //检查左孩子
            if(node->left){
                s.push(node->left);
            //检查右孩子，如果左孩子为空，那么根节点已经被遍历，所以需要出栈
            }else if(node->right){
                s.pop();
                s.push(node->right);
            //如果左右孩子都为空，那么当前节点出栈
            }else{
                s.pop();
                //如果当前出栈的是父节点的左孩子
                //则需要判断，父节点的右孩子是否还存在，不然会陷入死循环
                while(!s.empty()){
                    TreeNode* temp_node  = s.top();
                    //如果父节点有右孩子，那右孩子肯定是没有被访问过的
                    if(temp_node->right){
                        //父节点已经被访问过了，所以可以删除
                        s.pop();
                        s.push(temp_node->right);
                        break;
                    //如果没有，则父节点出栈
                    }else{
                        //父节点被访问过了，删除
                        s.pop();
                    }
                }
            }
        }
        return vec;
    }
};

2. 中序遍历的非递归实现

LeetCode 94

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>vec;
        if(root==NULL){
            return vec;
        }
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()){
            TreeNode* node = s.top();
            if(node->left){
                s.push(node->left);
            }else if(node->right){
                //如果节点有右孩子，那么打印当前的节点
                vec.push_back(node->val);
                // 节点已经没有作用了，出栈，并保存右孩子
                s.pop();
                s.push(node->right);
            }else{
                vec.push_back(node->val);
                s.pop();
                //判断父节点是否有右孩子
                while(!s.empty()){
                    TreeNode* temp_node = s.top();
                    vec.push_back(temp_node->val);
                    //如果有右孩子
                    if(temp_node->right){
                        //当前节点出栈，
                        s.pop();
                        s.push(temp_node->right);
                        break;
                    }else{
                        s.pop();
                    }
                }
            }
        }
        return vec;
    }
};

3. 后序遍历的非递归实现

LeetCode 145

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        if(root==nullptr){
            return vec;
        }
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()){
            TreeNode* node = s.top();
            if(node->left){
                s.push(node->left);
            }else if(node->right){
                s.push(node->right);
            }else{
                vec.push_back(node->val);
                s.pop();
                while(!s.empty()){
                    TreeNode* temp_node = s.top();
                    //如果当前节点是上一个节点的左孩子
                    if(temp_node->left==node){
                        if(temp_node->right){
                            s.push(temp_node->right);
                            break;
                        }else{
                            vec.push_back(temp_node->val);
                            s.pop();
                            node = temp_node;
                        }
                    //如果当前节点是上一个节点的右孩子，
                    //或者上一个节点，没有右孩子
                    }else if(temp_node->right==node||temp_node->right==nullptr){
                        vec.push_back(temp_node->val);
                        s.pop();
                        node = temp_node;
                    }
                }
            }
        }
        return vec;
        // vec.push_back(ro);
    }
};

4. 求二叉树的深度

https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/

思路：使用前序，中序，或者后序中的任何一种方法，遍历二叉树，达到叶子节点就检测当前的深度是不是最大深度。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==nullptr){
            return 0;
        }else{
            traversal(root,0);
            return max_depth;
        }
    }
    void traversal(TreeNode* node,int cur_depth){
        cur_depth+=1;
        // cout<<cur_depth<<endl;
        if(node->left){
            traversal(node->left,cur_depth);
        }
        if(node->right){
            traversal(node->right,cur_depth);
        }
        if(cur_depth>max_depth){
            max_depth=cur_depth;
        }
    }
    int max_depth = 0;
};

5. 求二叉搜索树第k大的节点

https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/

在这里插入代码片