刷题记录4---二叉树的中序遍历+对称二叉树+二叉树的最大深度+翻转二叉树+二叉树的直径

已于 2022-05-14 17:05:06 修改
阅读量1.1k 收藏
点赞数 1
分类专栏： 算法和数据结构 文章标签： 数据结构 算法
于 2022-04-24 23:14:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39721240/article/details/124392968
版权

前言

所有题目均来自力扣题库中的hot 100，之所以要记录在这里，只是方便后续复习

94.二叉树的中序遍历

题目：
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
示例 1：
二叉树的中序遍历示意图

输入：root = [1,null,2,3]
输出：[1,3,2]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
解题思路：
【递归】中序遍历即先遍历左节点，再遍历根节点，最后遍历右节点；可采用递归的方法，也可以才使用栈的方法
代码（python）：

# 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 inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        result = list()
        self.test(root, result)
        return result

    def test(self, root, result):
        if not root:
            return
        # 先遍历左节点，再将根节点的值放入结果，再遍历右节点
        self.test(root.left, result)
        result.append(root.val)
        self.test(root.right, result)

代码（java）：

**
 * 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 List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> array = new ArrayList<>();
        // 定义栈
        Deque<TreeNode> stack = new LinkedList<>();
		// 根节点不为空 或者 栈不为空
        while (root != null || ! stack.isEmpty()){
        	// 先将根节点的左节点全都放入栈（直到左节点为空）
            while (root != null){
                stack.push(root);
                root = root.left;
            }
            // 弹出节点，将节点加入结果中，再让节点等于右节点（开始迭代右节点）
            root = stack.pop();
            array.add(root.val);
            root = root.right;
        }
        
        return array;

知识点：

  • 二叉树先序遍历：根节点——左节点——右节点；中序遍历：左节点——根节点——右节点；后序遍历：左节点——右节点——根节点

原题链接：二叉树的中序遍历

101.对称二叉树

题目：
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：
对称二叉树示意图

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
解题思路：
【递归】二叉树问题多考虑递归；对称节点规律：左右两个节点都为空则对称；左右两个节点一个为空一个不为空则不对称；两个节点都不为空，判断两个节点值是否相等，且左节点的右子树和右节点的左子数是否对称，且左节点的左子数和右节点的右子树是否对称
代码（python）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if root is None:
            return True
        return self.test(root.left, root.right)
    
    def test(self, l, r):
        if l is None and  r is None:
            return True
        if l is not None and r is not None:
            if l.val != r.val:
                return False
            else:
                return self.test(l.right, r.left) and self.test(l.left, r.right)
        else:
            return False

代码（java）：

/**
 * 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) {
        return test(root.left, root.right);
    }
    // 转化为判断左右两个节点是否对称
    public boolean test(TreeNode node1, TreeNode node2){
        // 如果两个节点都为空则对称
        if (node1 == null && node2 == null){
            return true;
        }
        // 如果有一个节点为空，一个节点不为空，则不对称
        if (node1 == null || node2 == null){
            return false;
        }
        // 如果两个节点都不为空，判断两个节点值是否相等 且左节点的右子树和右节点的左子数是否对称 且左节点的左子数和右节点的右子树是否对称
        return node1.val == node2.val && test(node1.left, node2.right) && test(node1.right, node2.left);
    }
}

知识点：

  • 无

原题链接：对称二叉树

104.二叉树的最大深度

题目：
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
解题思路：
【递归】二叉树的题多考虑递归；可转化为左节点的最大深度 与 右节点的最大深度 的较大值 加上1（即当前根节点），递归的中止条件是 节点为空的情况，最大深度即为0
代码（python）：

# 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: TreeNode
        :rtype: int
        """
        # 如果当前节点为空  则返回深度为0
        if not root:
            return 0
        # 不为空，则返回左节点的最大深度 和 右节点的最大深度 之中的较大值 再 + 1 （当前节点）
        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1

代码（java）：

/**
 * 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;
        }
        return 1 + Math.max(maxDepth(root.right), maxDepth(root.left));
    }

    
}

知识点：

  • 无

原题链接：二叉树的最大深度

226.翻转二叉树

题目：
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：
翻转二叉树示意图

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]
解题思路：
【递归】二叉树多考虑递归；先将左节点翻转，再将右节点翻转，最后将两个节点对调即完成了二叉树的翻转；左右两个节点翻转方式是一样的，即递归；递归的中止条件是当前节点为空，直接返回空节点即可
代码（python）：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        self.invertTree(root.left)
        self.invertTree(root.right)
        node = root.left
        root.left = root.right
        root.right = node
        return root

代码（java）：

/**
 * 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;
        }
        // 先定义一个节点存放 翻转后的左节点
        TreeNode node = invertTree(root.left);
        // 让左节点等于翻转后的右节点
        root.left = invertTree(root.right);
        // 让右节点等于之前存放的翻转后的左节点
        root.right = node;
        //返回根节点即可
        return root;
    }

}

知识点：

  • 无

原题链接：翻转二叉树

543.二叉树的直径

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

      1
     / \
    2   3
   / \     
  4   5

返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

解题思路：
【递归】二叉树多考虑递归；经过当前节点的最多节点数应该是左节点的最大深度（最多节点）+右节点的最大深度（最多节点） + 1，我们可以递归得到左节点和右节点的最大深度，然后再取俩者较大值+ 1 则是当前节点的最大深度，递归的中止条件是当前节点为空，最大深度即为0，但是在这个过程中，我们要记录一个值用来存储经过当前节点的最多节点，并每次都进行比较取得最大值，在我们递归完成根节点取得根节点的最大深度后，也就意味着将经过每个节点的最大节点数都比较完成，最后再返回最大节点数 - 1 即 最大路径
代码（python）：

# 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):
    # 定义结果，表示最长路径经过的节点数
    result = 1

    def diameterOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.max_depath(root)
        # 直径即经过的节点数 - 1
        return self.result - 1 

    def max_depath(self, root):
        # 如果节点为空，则返回经过的节点为空
        if not root:
            return 0
        # 递归得到左节点中最大深度（即最长的节点数）
        max_left = self.max_depath(root.left)
        # 递归得到右节点中最大深度（即最长的节点数）
        max_right = self.max_depath(root.right)
        # 以当前节点为根节点的情况下，最长路径经过的节点数是左节点的最大深度 + 右节点的最大深度 + 当前节点； 并以此值和结果值比较 ，取较大者赋给结果值
        self.result = max(self.result, max_left + max_right + 1)
        # 返回当前节点的最大深度，即左右节点的最大神的较大者 + 1（当前节点）
        return max(max_left, max_right)  + 1

代码（java）：

/**
 * 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 result = 0;

    public int diameterOfBinaryTree(TreeNode root) {
        deep(root);
        return result - 1;
    }

    public int deep(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftMax = deep(root.left);
        int rightMax = deep(root.right);
        result = Math.max(result, leftMax + rightMax + 1);
        return Math.max(leftMax, rightMax) + 1;
    }
}

知识点：

  • 无

原题链接：二叉树的直径

热巴的小哥哥
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对称的二叉树
qq_35354887的博客
09-15 273
题目 请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。 思路 递归+对称 以先序遍历二叉树(中->左->右)，因为二叉树的对称性， 所以如果按照中->右->左遍历，那么两次遍历的结果应该是相同的。需要注意的是，如果二叉树各个结点值相同，那么上述结论将无法判断该二叉树是否是对称二叉树，因此我们需要在遍历到叶子结点...
LeetCode题解——101. 对称二叉树
溯夜，逆流而上
09-19 204
给定一个二叉树，检查它是否是镜像对称的。
Leetcode刷题--对称二叉树 考虑 中序遍历
weixin_43902248的博客
09-08 333
利用中序遍历判断二叉树的镜像对称问题
Leetcode对称二叉树算法与分析
Maple_PI的博客
09-11 318
@Leetcode对称二叉树 作为一道稍有进阶的数据结构经典题，对称二叉树的使用着实费了小白笔者不少脑筋。我一直在想能不能用先序后序遍历的方法解决，即在一棵树上做出判断，然而实际上解法并非如此。卖个关子，请看题干： 给定一个二叉树，检查它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 说明:...
二叉树的相关算法
Shannon_1997的博客
09-30 213
二叉树的相关算法 一、深度遍历 深度遍历分为前中后序遍历，每一种遍历又有两种方法，分别为递归和迭代。 （1）前序遍历 //递归实现 class Solution { public: void traversal(TreeNode* cur, vector<int>& vec) { if (cur == NULL) return; vec.push_back(cur->val); // 中 traversal(cur-&g
论文研究-PRAM模型下二叉树的中序遍历的并行算法 .pdf
08-16
PRAM模型下二叉树的中序遍历的并行算法，刘全升，，本文基于PRAM（Parallel Random Access Machine,并行共享存储器模型）模型讨论二叉树的中序遍历问题，提出了二叉树的中序遍历的一种并行算法�
中序遍历二叉树-java版本
04-26
在Java中，实现二叉树的中序遍历同样可以通过递归来完成。中序遍历的顺序是：首先递归地中序遍历左子树，然后访问根节点，最后递归地中序遍历右子树。 在这段代码中，Node类定义了二叉树的节点，BinaryTree类包含一...
二叉树遍历问题-前序， 中序， 后序
08-12
二叉树遍历问题 二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序...
课程设计报告数据结构二叉树遍历演示_二叉树中序遍历怎么看
01-08
课程设计报告数据结构二叉树遍历演示
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
已知二叉树的前序和中序遍历，打印后序遍历
03-26
已知二叉树的前序和中序遍历，打印后序遍历，采用二叉树的非递归算法，分享给大家~~
OJ-相同的树、对称二叉树、二叉树前序、中序、后序遍历、另一颗树的子树、平衡二叉树、二叉树的构建和遍历
weixin_46153828的博客
04-18 282
一、相同的树： bool isSameTree(struct TreeNode* p, struct TreeNode* q){ if(p==NULL&&q==NULL) { return true; } if(p==NULL||q==NULL) { return false; } return p->val==q->val && isSameTree(p->le
二叉树（五）：对称二叉树
qq_42138662的博客
06-19 5514
101.对称二叉树 给定一个二叉树，检查它是否是镜像对称的。 一、对称二叉树理论 对称二叉树如图所示，要判断一个二叉树是否为对称二叉树，实际上就是要判断根节点的左右两个子树是否镜像对称。因此，其解决方案为：按照对称的方式遍历左右子树，比较同时遍历的节点是否一致。而且在遍历过程中，只有两个子树的根节点对称了，继续比较左右子树是否对称才有意义，因此我们使用"中序遍历"（其实不是严格的中序遍历，只是我们先比较根节点） 按照遍历依赖的不同，可以分为以下三类方法： 递归法 基于队列的迭代法 基于栈的迭代法 .
Day15.二叉树层序遍历、对称二叉树
izwmain的博客
11-09 305
代码随想录，第15天，二叉树层序遍历
101. 对称二叉树——中序遍历也能解决
蜘蛛侠的博客
02-04 168
这道题可以说是很经典的二叉树的题目，题解大都给的是使用后序遍历来解决，以下我使用中序遍历也对其进行了解决，虽然效率不高但是也是一种拓展思维的方式。
【剑指offer系列】-28对称的二叉树(关键字：dfs中序遍历)
tmax52HZ的博客
09-11 298
public class Main28 { private static boolean isMirror(Tree root1, Tree root2) { //1.递归终止条件 if (root1 == null && root2 == null) return true; if ((root1 == null && root2 != null) || (root2 == null &amp
剑指28：对称的二叉树——递归+使用先序遍历和对称先序遍历
turry的博客
04-08 550
题目描述请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。Tips:先序遍历(根左右)  对称先序遍历(根右左) 依次对比 完成对称比较/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(...
力扣226.翻转二叉树（中序遍历）
xsybg的博客
01-25 799
代码随想录说，这个题如果用递归，前序后序遍历都可以，但是中序遍历很容易出错，我最开始一直没想出来，中序遍历为什么会出错呢？不就是左右孩子的位置换一下吗？ 直到我看了代码，就明白了。代码如下： class Solution { public TreeNode invertTree(TreeNode root) { if(root == null) return null; invertTree(root.left);//注意这里是left TreeNod
用C++求二叉树中序遍历的结果并打印，打印二叉树中序遍历的最后一个结点，打印二叉树中序遍历的第n个结点。
最新发布
05-12
用C++求二叉树中序遍历的结果并打印可以使用递归方法实现，具体步骤如下： 1. 如果当前结点为空，返回。 2. 递归遍历左子树。 3. 输出当前结点。 4. 递归遍历右子树。 中序遍历的最后一个结点即为二叉树的最右下角结点，可以在递归遍历时记录最后一个结点。 中序遍历的第n个结点可以在递归遍历时使用一个计数器来记录当前是第几个结点，并在遍历到第n个结点时输出。 以下是示例代码： ```c++ #include <iostream> using namespace std; // 二叉树结点定义 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; void inorderTraversal(TreeNode* root) { if (root == NULL) { return; } inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } TreeNode* getInorderLastNode(TreeNode* root) { if (root == NULL) { return NULL; } while (root->right != NULL) { root = root->right; } return root; } int getInorderNthNode(TreeNode* root, int n, int& count) { if (root == NULL) { return -1; } int res = getInorderNthNode(root->left, n, count); if (count == n) { return root->val; } count++; if (res != -1) { return res; } return getInorderNthNode(root->right, n, count); } int main() { // 构建一个二叉树 TreeNode* root = new TreeNode(1); root->left = new TreeNode(2); root->right = new TreeNode(3); root->left->left = new TreeNode(4); root->left->right = new TreeNode(5); // 中序遍历 inorderTraversal(root); cout << endl; // 中序遍历的最后一个结点 TreeNode* lastNode = getInorderLastNode(root); cout << lastNode->val << endl; // 中序遍历的第n个结点 int n = 3; int count = 1; int nthNode = getInorderNthNode(root, n, count); cout << nthNode << endl; return 0; } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值