C++刷题笔记(20)——leetcode101、100、572、104、559、111

STATEABC

已于 2022-05-11 15:49:32 修改

阅读量243

点赞数

分类专栏：不知道能不能混口饭的C嘎嘎文章标签： c++ leetcode 算法数据结构

于 2022-05-11 10:29:09 首次发布

本文链接：https://blog.csdn.net/STATEABC/article/details/124683098

版权

不知道能不能混口饭的C嘎嘎专栏收录该内容

50 篇文章 2 订阅

订阅专栏

题目1：101.对称二叉树

在这里插入图片描述
要判断一个二叉树是否对称，首先要判断两个子树的根节点是否相等，然后判断子树的子树是否相等，
可以理解为比较的是根节点的左右子树是否相互翻转

解法一：递归法

这一题代码随想录的逻辑是非常清晰的，通过比较两个子树的里侧和外侧的元素是否相等
在这里插入图片描述
左子树的遍历顺序应该是左右中，右子树的遍历顺序为右左中。

首先排除空节点的情况：
1.左节点为空、右节点不为空
2.左节点不为空、右节点为空
3.左右节点都为空

当左右节点都不为空时，又有两种情况：
1.左右节点指向的值不等
2.左右节点指向的值相等

当左右节点指向的值相等时：
1.比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子
2.比较内侧是否对称：传入左节点的右孩子，右节点的左孩子
3.如果左右都对称就返回true ，有一侧不对称就返回false

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {             //传入的参数为左右子树节点
        if (left == NULL && right != NULL) return false;        //左节点为空、右节点不为空
        else if (left != NULL && right == NULL) return false;   //左节点不为空、右节点为空
        else if (left == NULL && right == NULL) return true;    //左右节点都为空
        else if (left->val != right->val) return false;         //左节点指向的值不等与右节点指向的值
        else {                                                  //左右节点指向的值相等，递归
            //下边可以简化为 return compare(left->left,right->right) && compare(left->left, right->right);
            bool ouside = compare(left->left, right->right);    //判断左子树的左孩子与右子树的右孩子是否相等
            bool inside = compare(left->left, right->right);    //判断左子树的右孩子与右子树的左孩子是否相等
            bool issame = ouside && inside;                     //判断左右子树是否相等
            return issame;
        }
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

代码每一步的逻辑非常清晰，体会之后就不难理解官方题解给出的代码：

class Solution {
public:
    bool check(TreeNode* p, TreeNode* q) {    //定义两个指针来遍历二叉树
        if (!p && !q) return true;            //两个指针都为空
        if (!p || !q) return false;           //另外两种指针情况
        return p->val == q->val && check(p->left, q->right) && check(p->right, q->left); //指针指向的值相等
    }

    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

解法二：迭代法

通过队列来比较左右子树是否互相翻转

这里要注意的是二叉树的遍历不是前中后序的遍历，也不是层序遍历
在这里插入图片描述

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);    //左子树头节点入队
        que.push(root->right);   //右子树头节点入队

        while (!que.empty()) {
            TreeNode* leftnode  = que.front(); que.pop();
            TreeNode* rightnode = que.front(); que.pop();
            if (!leftnode && !rightnode) continue;    //若左右节点为空，此时对称，跳过本次循环中余下尚未执行的语句，执行下一次循环
            if (!leftnode || !rightnode || (leftnode->val != rightnode->val)) return false;  //左右一个节点不为空，或者都不为空但数值不相同，返回false
            que.push(leftnode->left);    //左节点左孩子入队
            que.push(rightnode->right);  //右节点右孩子入队
            que.push(leftnode->right);   //左节点右孩子入队
            que.push(rightnode->left);   //右节点左孩子入队
        }
        return true;
    }
};

题目2：100.相同的树

在这里插入图片描述
其实解法和101是一样得，甚至代码只需要稍加修改就能直接用

解法一：递归法

class Solution {
public:
    bool compare(TreeNode* p, TreeNode* q) {
        if (p == NULL && q != NULL) return false;      
        else if (p != NULL && q == NULL) return false;   
        else if (p == NULL && q == NULL) return true; 
        else if (p->val != q->val) return false;  
        else {   
            //下边可以简化为 return compare(left->left,right->left) && compare(left->right, right->right);
            bool ouside = compare(p->left, q->left);   
            bool inside = compare(p->right, q->right); 
            bool issame = ouside && inside;  
            return issame;
        }
    }
    bool isSameTree(TreeNode* p, TreeNode* q) {
        return compare(p,q);
    }
};

同样，简洁的代码也可以稍加修改：

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (p == NULL && q == NULL) return true;    //等同于 if (!p && !q) return true;
        if (p == NULL || q == NULL) return false;   //等同于 if (!p || !q) return false;
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

解法二：迭代法

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (p == NULL && q == NULL) return true;
        if (p == NULL || q == NULL) return false;
        queue<TreeNode*> que;
        que.push(p);
        que.push(q);
        while (!que.empty()) {
            TreeNode* pnode = que.front(); que.pop();
            TreeNode* qnode = que.front(); que.pop();
            if (!pnode && !qnode) continue;
            if (!pnode || !qnode || (pnode->val != qnode->val)) return false;
            que.push(pnode->left);
            que.push(qnode->left);
            que.push(pnode->right);
            que.push(qnode->right);
        }
        return true;
    }
};

题目3：572.另一颗树的子树

在这里插入图片描述

要判断subroot是不是root的子树，可以判断subroot是否和root的任意子树相等，不就又和100题差不多了。

解法：递归法

class Solution {
public:
    bool compare(TreeNode* root, TreeNode* subroot) {
        if (root == NULL && subroot != NULL) return false;      
        else if (root != NULL && subroot == NULL) return false;   
        else if (root == NULL || subroot == NULL) return true; 
        else if (root->val != subroot->val) return false;  
        else {   
            //下边可以简化为 return compare(left->left,right->left) && compare(left->right, right->right);
            bool ouside = compare(root->left, subroot->left);   
            bool inside = compare(root->right,subroot->right); 
            bool issame = ouside && inside;  
            return issame;
        }
    }
    bool isSubtree(TreeNode* root, TreeNode* subroot) {   
        if (subroot == NULL) return true;   //如果检验子树为空则一定包含
        if (root == NULL) return false;     //如果root为空则一定不包含
        return compare(root,subroot) || isSubtree(root->left, subroot) || isSubtree(root->right, subroot);  //重点就在这一句，subroot要么等于root本身、要么等于左子树、或右子树
    }
};

以上代码也可以进行简化：

class Solution {
public:
    bool compare(TreeNode* root, TreeNode* subroot) { // 从根节点开始遍历，找子树是否相等
        if (!root && !subroot) return true;   
        if ((!root && subroot) || (root && !subroot || (root->val != subroot->val))) return false;
        return compare(root->left,subroot->left) && compare(root->right,subroot->right);
    }
    bool isSubtree(TreeNode* root, TreeNode* subroot) {
        if (!root) return false;    //root为空则一定不包含
        return compare(root,subroot) || isSubtree(root->left,subroot) || isSubtree(root->right,subroot);
    }
};

或者：

class Solution {
public:
    bool compare(TreeNode* root, TreeNode* subroot) {
        if (root == nullptr && subroot == nullptr) return true;   //
        if (root == nullptr || subroot == nullptr) return false;
        return root->val == subroot->val && compare(root->left,subroot->left) && compare(root->right,subroot->right);
    }
    bool isSubtree(TreeNode* root, TreeNode* subroot) {
        if (!root) return false;
        return isSubtree(root->left,subroot) || compare(root,subroot) || compare(root->right,subroot);
    }
};

题目4：104.二叉树的最大深度

在这里插入图片描述
这里牵扯到二叉树的深度和高度，可以对比题110。
根节点的高度就是二叉树的最大深度。

解法一：递归法

求二叉树的最大深度，可以看成二叉树的最长子树加一(根节点)，那么先求左右子树的深度，然后取最大值

class Solution {
public:
    int getdepth(TreeNode* root) {
        if (root == NULL) return 0;                   //如果根节点为空则直接返回0
        int leftdepth = getdepth(root->left);         //左子树深度
        int rightdepth = getdepth(root->right);       //右子树深度
        int depth = max(leftdepth, rightdepth) + 1;   //二叉树深度
        return depth;
    }
    int maxDepth(TreeNode* root) {
        getdepth(root);
    }
};

精简代码可得:

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

解法二：迭代法

层序遍历一层一层的遍历二叉树，到遍历到最后一层，就是二叉树的深度。

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;              //层数
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

题目5：559.N叉树的最大深度

在这里插入图片描述
思路和104是一样的，只需要稍微修改下遍历的方式就可以了

解法一：递归法

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == NULL) return 0;
        int depth = 0;
        for (int i = 0; i < root->children.size(); i++) {
            depth = max(depth, maxDepth(root->children[i]));
        }
        return 1 + depth;
    }
};

解法二：迭代法

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == NULL) return 0;
        queue<Node*> que;
        que.push(root);
        int depth = 0;              //层数
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for (int i = 0; i < node->children.size(); i++) {
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
        }
        return depth;
    }
};

题目6：111.二叉树的最小深度

在这里插入图片描述

解法一：递归法

大致的思路和之前104是一样的，但是要注意一点，叶子节点是指没有子节点的节点，即左右节点都为空。

如果一个节点的左字节为空，右子节点不为空，那么肯定不是叶子节点，就要在它右子节点继续找叶子节点。

class Solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);
        int rightdepth = getdepth(node->right);   //这里还要进行判断是否为最低点
        if (node->left == NULL && node->right != NULL) return 1 + rightdepth;  //左子树空右子树不空
        if (node->left != NULL && node->right == NULL) return 1 + leftdepth;   //左子树不空右子树空
        return 1 + min(leftdepth, rightdepth);
    }
    int minDepth(TreeNode* root) {
        return getdepth(root);
    }
};

精简代码后：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right != NULL) return 1 + minDepth(root->right);  //左子树空右子树不空
        if (root->left != NULL && root->right == NULL) return 1 + minDepth(root->left);   //左子树不空右子树空
        return 1 + min(minDepth(root->left), minDepth(root->right));
    }
};

解法二：迭代法

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;                 //层数
        while (!que.empty()) {
            int size = que.size();
            depth++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (node->left == NULL && node->right == NULL) return depth;
            }
        }
        return depth;
    }
};

STATEABC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++刷题笔记(20)——leetcode101、100、572、104、559、111

题目1：101.对称二叉树题目2：100.相同的树题目3：572.另一棵树题目4：104.二叉树的最大深度题目5：559.N叉树的最大深度题目6：111.二叉树的最小深度
复制链接

扫一扫