DAY20|二叉树part4

最新推荐文章于 2024-07-20 09:51:47 发布

kirinenko

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量784

点赞数 30

分类专栏：代码随想录训练营打卡记录文章标签：算法数据结构 leetcode c++

本文链接：https://blog.csdn.net/weixin_47963219/article/details/138635452

版权

代码随想录训练营打卡记录专栏收录该内容

17 篇文章 0 订阅

订阅专栏

好几天没写了。。一上来就感觉生疏了。。。TAT

110.平衡二叉树

平衡二叉树是指该树所有节点的左右子树的深度相差不超过 1。
第一个想法：
迭代，遍历每个节点求深度（感觉时间复杂度会大就是了）

记录一下第一个版本：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {//迭代，遍历每个节点求深度
public:
    bool isBalanced(TreeNode* root) {
        if(root==nullptr) return true;
        queue<TreeNode*> myque;
        myque.push(root);
        while(myque.empty()==0){
            int size=myque.size();
            while(size--){
                TreeNode* t=myque.front();
                //if(t==root) cout<<hight(t->right);
                if(abs(hight(t->right)-hight(t->left))>1) return false;
                myque.pop();
                if(t->left) myque.push(t->left);
                if(t->right) myque.push(t->right);
            }
        }
        return true;
    }
    int hight(TreeNode* root){
        if(root==nullptr) return 0;
        return max(hight(root->left),hight(root->right))+1;
    }
};

求每个节点的深度是递归，遍历每个节点的过程是迭代

但感觉这里会有重复计算的问题，比如从上往下遍历节点的时候，下面有些节点其实在迭代求深度的时候已经迭代过了，但是遍历到这个节点的时候还需要重新迭代求深度。这里是不是简化掉？

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        int result=process(root);
        return result==-1 ? false : true;
    }
    int process(TreeNode* root){
        if(root==nullptr) return 0;
        int L=process(root->left);
        if(L==-1) return -1;
        int R=process(root->right);
        if(R==-1) return -1;
        int result;
        if(abs(L-R)>1) return -1;
        result=1+max(L,R);
        return result;
    }
};

第一个方案是从头节点开始遍历（层序遍历），但是考虑到重复计算，还是上面这个方法会更好。
以上方法是后序遍历（左右中），先从最下面开始往上递归。
递归终止条件还是空节点返回0.
递归返回值是当前节点为根节点的树的高度。
如果当前节点为非平衡二叉树，那直接返回-1.
如果遍历过程中有返回-1的过程，那在后续递归过程中都返-1。
如果对于当前节点，发现返回的左右子树高度相差超过1，那么也返回-1.
以上。

257 二叉树的所有路径

很典型的回溯算法，为了得到所有结果，走完一条路的时候还需要返回岔路口走其他的路。

看题解：
一开始写成了这样：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        if(root==nullptr) return result;
        vector<int> each;
        process(root,each,result);
        return result;

    }
    void process(TreeNode* root, vector<int>& each, vector<string>& result){
        each.push_back(root->val);
        if(root->left==nullptr &&root->right==nullptr){
            string s="";
            int size=each.size();
            for(int i=0;i<size;++i){
                s+=(each[i]+'0');
                if(i!=size-1) s+="->";
            }
            result.push_back(s);
            return;
        }
        if(root->left){
            process(root->left,each,result);
            each.pop_back();
        }
        if(root->right){
            process(root->right,each,result);
            each.pop_back();
        }
    }
};

报错如下：
报错1
涉及到要把int类型强制转换为string类型：
使用to_string函数

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        if(root==nullptr) return result;
        vector<int> each;
        process(root,each,result);
        return result;

    }
    void process(TreeNode* root, vector<int>& each, vector<string>& result){
        each.push_back(root->val);
        if(root->left==nullptr &&root->right==nullptr){
            string s="";
            int size=each.size();
            for(int i=0;i<size;++i){
                s+=to_string(each[i]);
                
                if(i!=size-1) s+="->";
            }
            result.push_back(s);
            return;
        }
        if(root->left){
            process(root->left,each,result);
            each.pop_back();
        }
        if(root->right){
            process(root->right,each,result);
            each.pop_back();
        }
    }
};

AC了。
递归的整体思路：
前序遍历，因为需要从头节点开始出发往下慢慢延伸找路。
终止条件：当前节点为叶节点，说明这一个路径已经结束了，先把当前each中的路径存入result，再return相当于进行一个回溯。
if(root->left){
process(root->left,each,result);
each.pop_back();
}
这一段代码先递归然后返回后进行一个pop_back，就是一个很明显的回溯，popback以后会继续往下执行，下面就是回溯后的上一个节点的right节点入当前路径，相当于“返回岔路口–>选择另一条路”。
“
我们知道，回溯和递归是一一对应的，有一个递归，就要有一个回溯。
”
所以回溯要和递归永远在一起。两个语句要挨起来，从递归中return回来了，相当于当前的路已经走完了，是时候回溯走下一条路了。

迭代法：
使用迭代法来模拟递归法需要用到栈来模拟。这里需要用到一个栈来模拟递归，用一个栈来存放路径。
照猫画虎写了一下但是感觉思路没想好。。先不说了。

二叉树周末总结部分：

100. 相同的树

思路：可以两棵树同时遍历，比较节点。可以递归可以迭代。
递归写个前序的吧：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        bool result=true;
        process(p,q,result);
        return result;
    }
    void process(TreeNode* p, TreeNode* q , bool& result){
        if(result==false) return;
        if(p==nullptr && q!=nullptr){
            result=false;
            return;
        }
        if(p!=nullptr && q==nullptr){
            result=false;
            return;
        }
        if(p==nullptr && q==nullptr) return;
        if(p->val !=q->val){
            result=false;
            return;
        }
        
        process(p->left,q->left,result);
        process(p->right,q->right,result);
    }
};

迭代，对层序遍历比较熟练，写一下：
一开始这样写的，发现有测试用例不通过以后才知道这样逻辑有问题：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        queue<TreeNode*> pst;
        queue<TreeNode*> qst;
        if(p==nullptr && q!=nullptr) return false;
        if(p!=nullptr && q==nullptr) return false;
        if(p==nullptr && q==nullptr) return true;
        pst.push(p);
        qst.push(q);
        while(qst.empty()==0 && pst.empty()==0){
            TreeNode* p_node=pst.front();pst.pop();
            TreeNode* q_node=qst.front();qst.pop();
            if(p_node->val !=q_node->val) return false;
            if(p_node->left) {
                pst.push(p_node->left);
                if(q_node->left) qst.push(q_node->left);
                else return false;
            }
            if(p_node->right){
                pst.push(p_node->right);
                if(q_node->right) qst.push(q_node->right);
                else return false;
            } 
        }
        if(qst.empty()!=pst.empty()) return false;
        return true;
    }
};

未通过的用例
修改：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        queue<TreeNode*> pst;
        queue<TreeNode*> qst;
        if(p==nullptr && q!=nullptr) return false;
        if(p!=nullptr && q==nullptr) return false;
        if(p==nullptr && q==nullptr) return true;
        pst.push(p);
        qst.push(q);
        while(qst.empty()==0 && pst.empty()==0){
            TreeNode* p_node=pst.front();pst.pop();
            TreeNode* q_node=qst.front();qst.pop();
            if(p_node->val !=q_node->val) return false;
            if(p_node->left!=nullptr && q_node->left!=nullptr) {
                pst.push(p_node->left);
                qst.push(q_node->left);
                
            }
            else if(p_node->left==nullptr && p_node->left==q_node->left){}
            else return false;
            if(p_node->right!=nullptr && q_node->right!=nullptr){
                pst.push(p_node->right);
                qst.push(q_node->right);
            } 
            else if(p_node->right==nullptr && p_node->right==q_node->right){}
            else return false;
        }
        if(qst.empty()!=pst.empty()) return false;
        return true;
    }
};

感觉这里判断条件有点赘述了，题解里的会更精简，这里先不再修改。

572 另一棵树的子树

思路：先遍历root树的所有节点，遍历的时候与subRoot一一对比，如果对的上，就开始取这两个节点判断子树是否相同（比较部分可以直接套用100题的代码）
根据题中描述可知两棵树都不会出现NULL的情况，所以暂不考虑这种情况。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        bool result=false;
        find_all_nodes(root, subRoot,result);
        return result;
    }
    void find_all_nodes(TreeNode* root, TreeNode* subRoot, bool& result){
        if(root==nullptr) return;
        if(result==true) return;//终止条件，如果确认已经有子树存在，那不需要遍历其他节点了
        //这里采用前序遍历
        if(root->val==subRoot->val){
            //bool temp_result=;
            if(isSameTree(root,subRoot)==true) {
                result=true;
                return;
            }
        }
        find_all_nodes(root->left,subRoot,result);
        find_all_nodes(root->right,subRoot,result);

    }
    bool isSameTree(TreeNode* p, TreeNode* q) {
        bool result=true;
        process(p,q,result);
        return result;
    }
    void process(TreeNode* p, TreeNode* q , bool& result){
        if(result==false) return;
        if(p==nullptr && q!=nullptr){
            result=false;
            return;
        }
        if(p!=nullptr && q==nullptr){
            result=false;
            return;
        }
        if(p==nullptr && q==nullptr) return;
        if(p->val !=q->val){
            result=false;
            return;
        }
        
        process(p->left,q->left,result);
        process(p->right,q->right,result);
    }
};

好了，跳出总结来做下一题：

404 左子叶之和

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        int result=0;
        process(root, result);
        return result;
    }
    void process(TreeNode* root, int& result){
        if(root==nullptr) return;
        if(root->left){
            TreeNode* L=root->left;
            if(L->left==nullptr && L->right==nullptr)
                result+=root->left->val;
            process(root->left,result);
        } 
        process(root->right,result); 
    }

};

注意是“左子叶”，必须是叶节点才能求和。
因为题解中的递归函数是有返回值的（返回当前之和）所以需要严格按照左右中的顺序来写，但我这个方法没有返回值，直接修改参数最后得到和。、
迭代法：
不写层序遍历，层序遍历遍历每层的时候可以判断当前节点是否叶节点，但无法判断是否左子叶，左子叶需要在父节点的基础上进行判断。
写个前序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> myst;
        if(root==nullptr) return 0;
        int result=0;
        myst.push(root);
        while(myst.empty()==0){
            TreeNode* t=myst.top();myst.pop();
            if(t->right)
                myst.push(t->right);
            if(t->left){
                if(t->left->left==nullptr && t->left->right==nullptr)
                    result+=t->left->val;
                myst.push(t->left);
            }
            
        }
        return result;
    }
};

kirinenko

关注

30
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
DAY20|二叉树part4

思路：可以两棵树同时遍历，比较节点。可以递归可以迭代。* };if(p!return;if(p->val!迭代，对层序遍历比较熟练，写一下：/*** int val;* };pst.pop();qst.pop();* };*/
复制链接

扫一扫