[代码随想录打卡Day14] 226.翻转二叉树 （优先掌握递归） 101. 对称二叉树 （优先掌握递归） 104.二叉树的最大深度 （优先掌握递归）111.二叉树的最小深度 （优先掌握递归）

于 2024-11-16 22:19:28 发布
阅读量577 收藏 19
点赞数 10
CC 4.0 BY-SA版权
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goodenough5/article/details/143824256

226.翻转二叉树 （优先掌握递归）

对左子树反转,对右子树反转,对当前节点左右节点反转.
只能使用前序或者后序遍历,因为如果使用中序遍历先对左子树反转再反转当前节点(这个时候左子树变成右子树,其余同理),然后在对当前右子树反转就是相当于原来右子树没有反转操作.所以不能使用中序.
递归三部曲:

  1. 确定递归函数的参数和返回值:节点,返回节点
  2. 确定终止条件:NULL return root
  3. 确定单层递归的逻辑: 当前节点反转,函数处理左节点,函数处理右节点
    C++,JAVA和Python的代码如下:
/**
 * 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* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root==null){//迭代结束条件
            return null;
        }
        swapChildren(root);//中
        invertTree(root.left);//左
        invertTree(root.right);//右
        return root;
    }
    public void swapChildren(TreeNode root){
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def invertTree(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: Optional[TreeNode]
        """
        if not root:
            return None
        root.left, root.right = root.right, root.left #这个就是交换中的左右孩子 中
        self.invertTree(root.left)#左
        self.invertTree(root.right)#右, 这个是Python特有的就是self
        return root

参考文章

  1. https://www.programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

101. 对称二叉树 （优先掌握递归）

一个二叉树对称怎么判断,判断这个二叉树它的两边左右子树是否对称,也就是左子树其中所有的子二叉树与其对应的右子树中的子二叉树对称.我们只有判断这个节点代表的子树的左右孩子和它对应的子树的右左孩子相等才能说明当前节点代表的子树和其对称的子树是对称的,否则是不对称的.
也就是只有对左右孩子进行遍历判断了才能判断最后输出.
在这里插入图片描述

下面是C++,JAVA,Python代码.

/**
 * 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 compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right == NULL) return true;
        else if(left == NULL && right != NULL) return false;
        else if(left != NULL && right == NULL) return false;//注意其中的left和right不是左右孩子,可以理解为左右子树的指针,他们移动是对称的
        else if(left->val != right->val) return false;
        bool outside = compare(left->left, right->right);//外侧的对称节点
        bool inside = compare(left->right, right->left);//内侧的对称节点
        bool result = outside && inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL) return true;
        return compare(root->left, root->right);
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return false;
        return compare(root.left, root.right);
    }
    boolean compare(TreeNode left, TreeNode right){
        if(left==null && right==null) return true;
        else if(left!=null && right==null) return false;
        else if(left==null && right!=null) return false;
        else if(left.val != right.val) return false;
        boolean outside = compare(left.left, right.right);
        boolean inside = compare(left.right, right.left);
        boolean result = outside && inside;
        return result;
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: bool
        """
        if root is None:
            return True
        return self.compare(root.left, root.right)

    
    def compare(self, left, right):
        if left == None and right == None:
            return True
        elif left != None and right == None:
            return False
        elif left == None and right != None:
            return False
        elif left.val != right.val:
            return False
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside and inside

参考文章

  1. https://www.programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

104.二叉树的最大深度 （优先掌握递归）

高度:当前节点到叶子节点的距离.
深度:当前节点到根节点的距离.
计算高度的思想接近于后序遍历.将子节点的高度告诉当前节点,当前节点高度=其子节点最大高度+1
计算深度的思想接近于前序遍历.
根节点的高度=最大深度.
还有后面的二叉树的最小深度可以用后序遍历的模板一套写下来.
下面是C++,JAVA,Python代码.

/**
 * 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==NULL) return 0;
        int leftheight = maxDepth(root->left);//左
        int rightheight = maxDepth(root->right);//右
        int height = 1 + max(leftheight, rightheight);//中,接收左右孩子的最大高度,然后加1得到当前节点的高度
        return height;
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        int leftheight = maxDepth(root.left);
        int rightheight = maxDepth(root.right);
        int height = 1 + Math.max(leftheight, rightheight);
        return height;
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if(root==None):
            return 0
        leftheight = self.maxDepth(root.left)
        rightheight = self.maxDepth(root.right)
        height = 1+max(leftheight, rightheight)
        return height

参考文章

  1. https://www.programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html

111.二叉树的最小深度 （优先掌握递归）

注意最小深度的定义:根节点到最近的叶子节点的距离.
需要考虑左右节点有一个为空的情况.相比于最大的深度添加了一些判断语句来完善这个计算不会出错.
也是使用的后序遍历.
下面是C++,JAVA和Python的代码

/**
 * 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==NULL) return 0;//如果空节点就返回0,高度是0
        int leftheight = minDepth(root->left);//左
        int rightheight = minDepth(root->right);//右,获得左右孩子的高度就可以得到当前节点的高度
        if(root->left == NULL && root->right != NULL) return 1+rightheight;//处理其中一个节点为空另一个不为空的情况
        if(root->left != NULL && root->right == NULL) return 1+leftheight;//处理其中一个节点为空另一个不为空的情况
        int result = 1+min(leftheight, rightheight);//包括左右孩子都为空或者都不为空的情况
        return result;
        
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        int leftheight = minDepth(root.left);
        int rightheight = minDepth(root.right);
        if(root.left!=null && root.right==null) return 1+leftheight;
        if(root.left==null && root.right!=null) return 1+rightheight;
        int result = 1+Math.min(leftheight, rightheight);
        return result;
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if(root==None):
            return 0
        leftheight = self.minDepth(root.left)
        rightheight = self.minDepth(root.right)
        if(root.left == None and root.right != None):
            return 1+rightheight
        if(root.left != None and root.right == None):
            return 1+leftheight
        result = 1+min(leftheight, rightheight)
        return result

参考文章

  1. https://www.programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html
鱼小丸
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值