7月10日-周一

最新推荐文章于 2024-09-29 16:46:50 发布

真名怎么看

最新推荐文章于 2024-09-29 16:46:50 发布

阅读量55

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/qq_43686922/article/details/131631564

版权

本文介绍了如何使用迭代和递归方法解决力扣上的三个问题：104号问题（二叉树的最大深度）、111号问题（二叉树的最小深度）和101号问题（对称二叉树）。对于最大深度和最小深度，分别展示了基于队列的层序遍历和递归的解决方案。对称二叉树的检查则通过比较左右子树的对应节点来实现。

摘要由CSDN通过智能技术生成

一、刷题

力扣104，二叉树的最大深度

迭代法

层序遍历，在统计size时depth++即可

整体代码

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* cur = que.front();
                que.pop();
                if (cur->left != NULL) que.push(cur->left);
                if (cur->right != NULL) que.push(cur->right);
            }
        }
        return depth;
    }
};

递归法

1.终止条件

节点为空时返回0

if (root == NULL) return 0;

2.单层递归逻辑

递归求左右子树的深度，返回左右子树的最大深度加一

        int leftDepth = maxDepth(root->left);
        int rightDepth = maxDepth(root->right);
        return 1 + max(leftDepth, rightDepth);

整体代码

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

力扣111，二叉树的最小深度

递归法

1.终止条件

当前节点为空时返回0

if (root == NULL) return 0;

2.单层递归逻辑

递归求左右子树的深度，与最大深度不同要判断左右节点为空的情况，因为当一个为空，一个不为空时最小深度并不是0.

        int leftDepth = minDepth(root->left);
        int rightDepth = minDepth(root->right);
        if (root->left != NULL && root->right == NULL) return 1 + leftDepth;
        if (root->left == NULL && root->right != NULL) return 1 + rightDepth;
        return 1 + min(leftDepth, rightDepth);

整体代码

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int leftDepth = minDepth(root->left);
        int rightDepth = minDepth(root->right);
        if (root->left != NULL && root->right == NULL) return 1 + leftDepth;
        if (root->left == NULL && root->right != NULL) return 1 + rightDepth;
        return 1 + min(leftDepth, rightDepth);
    }
};

迭代法

大致和最大深度相似使用层序遍历，但是当左右孩子都为空时即是最小深度

整体代码

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* cur = que.front();
                que.pop();
                if (cur->left != NULL) que.push(cur->left);
                if (cur->right != NULL) que.push(cur->right);
                if (cur->left == NULL && cur->right == NULL) return depth;//当左右孩子都为空时说明为最校深度
            }
        }
        return depth;
    }
};

力扣101，对称二叉树

递归法

这题最终要的一点是要明白，要对称是要比较（left->left和right->right）与（left->right和right->left）并不是比较左右子节点是否一样。

1.递归函数的参数和返回值

单独写函数传入左右节点，注意这里比较的并不是左右子节点

bool compare(TreeNode* left, TreeNode* right)

2.终止条件

当左右为空或者左右不为空并且值相等时为true

        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;

3.单层递归逻辑

比较（left->left和right->right）与（left->right和right->left）

        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return inside && outside;

整体代码

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;
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        return inside && outside;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

迭代法

使用队列，也是比较（left->left和right->right）与（left->right和right->left）

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 == NULL && rightNode == NULL) continue;
            if (leftNode == NULL || rightNode == NULL || leftNode->val != rightNode->val) return false;

            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);
        }
        return true;
    }
};