算法练习小结

最新推荐文章于 2024-07-25 21:13:04 发布

Sirius小狼

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量70

点赞数

分类专栏： C、C++ 文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_41824716/article/details/119861088

版权

C、C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

二叉树的最小深度

题目介绍：

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

问题分析：

每个节点的最小深度都可以分解为左右子树中较小深度的树的深度加1，用公式来表达就是root_depth = 1 + min(leftChild_depth, rightChild_depth)，然后每颗子树也可以这样分解，所以很明显这可以用递归来解决。

方法步骤：

1、当节点为空时，返回深度为0；

2、当节点的左右子树均为空时，返回深度为1；

3、当节点左子树为空，右子树存在时，返回右子树的深度加1；

4、当节点右子树为空，左子树存在时，返回左子树的深度加1；

5、当节点的左右子树均存在，返回较小深度的子树的深度加1；

细节：

唯一需要注意的点就是某个节点有一颗子树为空，一颗子树不为空时，不能取较小深度的子树的深度，因为那就是0，不符合实际情况，所以应该返回不为空的那颗子树的深度。

/**
 * 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 minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        if(root->left==nullptr and root->right==nullptr) return 1;
        if(root->left==nullptr and root->right!=nullptr) return 1+minDepth(root->right);
        if(root->left!=nullptr and root->right==nullptr) return 1+minDepth(root->left);
        return 1+min(minDepth(root->left),minDepth(root->right));
    }
};

二叉树的最大深度

题目介绍：

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

问题分析：

每个节点的最大深度都可以分解为左右子树中较大深度的树的深度加1，用公式来表达就是root_depth = 1 + max(leftChild_depth, rightChild_depth)，然后每颗子树也可以这样分解，所以很明显这可以用递归来解决。

方法步骤：

1、当节点为空时，返回深度为0；

2、当节点的左右子树均为空时，返回深度为1；

3、当节点存在子树时，返回较大深度的子树的深度加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:
    int maxDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        if(root->left==nullptr and root->right==nullptr) return 1;
        return 1+max(maxDepth(root->left), maxDepth(root->right));
    }
};

N叉树的最大深度

题目介绍：

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

问题分析：

每个节点的最大深度都可以分解为子树中较大深度的树的深度加1，用公式来表达就是root_depth = 1 + max(child_01_depth, child_02_depth, ...., child_N_depth)，然后每颗子树也可以这样分解，所以很明显这可以用递归来解决。

方法步骤：

1、当节点为空时，返回深度为0；

2、当节点的所有子树均为空时，返回深度为1；

3、当节点存在子树时，返回较大深度的子树的深度加1；

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

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

相同二叉树

题目介绍：

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

问题分析：

当两颗二叉树的相同位置上的节点值不等时，很明显这两颗二叉树不相同，若相等，则判断各自节点的左子树和右子树上的节点值是不是分别相等，然后左子树和右子树也可以这样分解，很明显这就可以用递归来解决。

方法步骤：

1、当两颗树的节点均为空节点时，返回true；

2、当两颗树的节点有一个为空，一个不为空时，返回false；

3、判断两节点值是否相等、两节点的左子树是否相等、两节点的右子树是否相等，返回并运算结果。

/**
 * 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) {
        if(p==nullptr and q==nullptr) return true;
        if(p==nullptr or q==nullptr) return false;
        return p->val==q->val and isSameTree(p->left, q->left) and isSameTree(p->right, q->right);
    }
};

对称二叉树

题目介绍：

给定一个二叉树，检查它是否是镜像对称的。

问题分析：

当这颗二叉树的对称位置上的节点值不等时，很明显这颗二叉树不对称，若相等，则判断节点1的左子树和节点2的右子树是否相等，以及节点1的右子树和节点2的左子树是否相等，接着将节点1的左子树和节点2的右子树，以及节点1的右子树和节点2的左子树用这个方法分解，很明显这就可以用递归来解决。

方法步骤：

1、当根节点为空时，返回true，否则代入其左右子树；

2、当节点1的左子树和节点2的右子树均为空时，返回true；

3、当节点1的左子树和节点2的右子树有一个为空，一个不为空时，返回false；

4、判断两节点值是否相等、节点1的左子树和节点2的右子树是否相等、节点1的右子树和节点2的左子树是否是否相等，返回并运算结果。

/**
 * 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 is_Symmetric(TreeNode* p, TreeNode* q)
    {
        if(p==nullptr and q==nullptr) return true;
        if(p==nullptr or q==nullptr) return false;
        return p->val==q->val and is_Symmetric(p->left, q->right) and is_Symmetric(p->right, q->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        return is_Symmetric(root->left, root->right);
    }
};

二叉树的直径

题目介绍：

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

问题分析：

求某个节点的直径长度，就是左子树和右子树的最大直径长度相加，就是该节点的直径长度了。而返回给父节点的值是该节点左子树和右子树的较大直径长度加1，

方法步骤：

1、当节点为空时，返回0；

2、分别计算左右节点的直径长度；

3、若左右节点的直径长度之和大于目前最大值，则更新最大值，然后返回左右节点中较大的直径长度加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:
    int func(TreeNode* root, int &diameter)
    {
        if(root==nullptr) return 0;
        int leftNum = func(root->left, diameter);
        int rightNum = func(root->right, diameter);
        if(leftNum+rightNum>diameter)
            diameter=leftNum+rightNum;
        return 1+max(leftNum,rightNum);
    }
    int diameterOfBinaryTree(TreeNode* root) {
        int diameter=0;
        func(root, diameter);
        return diameter;
    }

};

合并二叉树

题目介绍：

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

问题分析：

这道题完全可以不创建新节点来实现，直接在root1上修改即可。分别同时递归root1和roo2的左子树和右子树，这就分解成一个个子树问题，返回最终修改的子树即可。

方法步骤：

1、当两节点都为空时，返回null；

2、当一个节点为空，一个节点不为空，返回不为空的节点；

3、当两个节点都不为空，两个节点值相加并赋给root1，接着分别合并两个节点的左子树和右子树，返回root1；

/**
 * 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:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr and root2==nullptr)   return nullptr;
        if(root1==nullptr and root2!=nullptr)   return root2;
        if(root1!=nullptr and root2==nullptr)   return root1;  
        root1->val+=root2->val;
        root1->left = mergeTrees(root1->left, root2->left);
        root1->right = mergeTrees(root1->right, root2->right);
        return root1;
    }
};

Sirius小狼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法练习小结

目录二叉树的最小深度二叉树的最大深度N叉树的最大深度二叉树的最小深度/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) :
复制链接

扫一扫

专栏目录