• leetcode-----二叉树习题

     目录

    前言

    1. 二叉树的中序遍历

    2. 相同的树

    3. 二叉树的最大深度

    4. 二叉树的最小深度

    5.二叉树的前序遍历

    6. 二叉树的后序遍历

    7. 对称二叉树

    前言

            前面我们学习过了二叉树的相关知识点，那么今天我们就做做练习，下面我会介绍几道关于二叉树的leetcode习题，我们一起来看看吧！

    二叉树相关链接：

    二叉树的基本操作：数据结构-----二叉树的基本操作-CSDN博客

    二叉树的创建和遍历：数据结构-----二叉树的创建和遍历-CSDN博客

    二叉树的基础知识点：数据结构-----树和二叉树必知必会知识_Gretel Tade的博客-CSDN博客

    堆的相关方法代码实现：数据结构-----堆(完全二叉树)-CSDN博客

    1. 二叉树的中序遍历

     给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

    思路分析：

     这道题是这样要求的，给入一个int类型的指针num，要求去进行动态空间的分配为数组，然后去进行中序遍历二叉树节点，把得到的数据存入到这个数组里面去，最后输出这个数组，也就是说中序遍历的同时还会去拿到数据进行储存。

     代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9.  
    10. void travel(struct TreeNode* root, int*num,int*returnSize){
    11.         if(!root)
    12.             return;
    13.         travel(root->left,num,returnSize);
    14.         num[*returnSize]=root->val;
    15.         *returnSize+=1;
    16.         travel(root->right,num,returnSize);
    17. }
    18. /**
    19.  * Note: The returned array must be malloced, assume caller calls free().
    20.  */
    21. int* inorderTraversal(struct TreeNode* root, int* returnSize){
    22.     int* num=(int*)malloc(sizeof(int)*100);
    23.     *returnSize=0;
    24.     if(!root)
    25.         return NULL;
    26.     travel(root,num,returnSize);
    27.     return num;
    28.         
    29. }


    2. 相同的树

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

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

    思路分析：

     要判断是否相同的树，就要判断同一个位置的节点是否存在，存在的同时里面的值是否相同，那就分以下三种情况。第一：节点都不存在，那么这就是满足条件true；第二：一个节点存在一个不存在，那就是false；第三：里面的值不同，结果还是false。对以上的三种情况进行左子树和右子树遍历取和运算即可。

    代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9. bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    10.   
    11.     if(!p&&!q)
    12.         return true;
    13.     if(!p||!q)
    14.     return false;
    15.     if(p->val!=q->val)
    16.     return false;
    17.     return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
    18. }

    3. 二叉树的最大深度

    给定一个二叉树 root ，返回其最大深度。

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

    思路分析：

    获取最大深度，那就是每次向左右子树进行遍历，取每次遍历一层就进行深度+1，最后递归到根节点的时候，比较此时左右子树当前深度的大小，取其中大的一个返回即可。

     代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9.  
    10.  
    11. int maxDepth(struct TreeNode* root){
    12.     if(!root){
    13.         return 0;
    14.     }
    15.     int l=maxDepth(root->left);
    16.     int r=maxDepth(root->right);
    17.     if(l>r)
    18.     return l+1;
    19.     else
    20.     return r+1;
    21. }

    4. 二叉树的最小深度

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

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

    说明：叶子节点是指没有子节点的节点。

    思路分析：

    跟上面求最大深度不同，这里就要去分三种情况来讨论了，首先就是如果这个树只有右子树没有左子树，那么返回的值就是从右子树遍历的结果；如果只有左子树没有右子树，那么返回的深度也就是左子树遍历的结果，如果左右子树都有的话，那么返回的深度就是其中较小者的值。

    代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9. int minDepth(struct TreeNode* root){
    10.     if(!root){
    11.         return 0;
    12. }
    13.     else if(!root->left&&root->right)
    14.         return minDepth(root->right)+1;
    15.     else if(!root->right&&root->left)
    16.         return minDepth(root->left)+1;
    17.     else {
    18.         int l=minDepth(root->left);
    19.         int r= minDepth(root->right);
    20.         if(l>r)
    21.             return r+1;
    22.         else
    23.             return l+1;
    24.     }
    25. }


    5.二叉树的前序遍历

    给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 

    思路分析：

    跟中序遍历是一样的，先进行分配储存数据的数组空间，然后进入到前序遍历的过程中，一边储存数据，一边遍历，最后的遍历结果就是直接输出这个数组储存到的数据即可。

     代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9. /**
    10.  * Note: The returned array must be malloced, assume caller calls free().
    11.  */
    12. void travel(struct TreeNode* root, int *num,int* returnSize)
    13. {
    14.     if(!root)
    15.         return;
    16.     num[*returnSize]=root->val;
    17.     *returnSize+=1;
    18.     travel(root->left,num,returnSize);
    19.     travel(root->right,num,returnSize);
    20. }
    21. int* preorderTraversal(struct TreeNode* root, int* returnSize){
    22.   
    23.     int* num=(int*)malloc(sizeof(int)*100);
    24.     *returnSize=0;
    25.     travel(root,num,returnSize);
    26.     return num;
    27.     
    28.    
    29. }


    6. 二叉树的后序遍历

    给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。 

    思路分析：

    方法还是跟上面一样的，通过分配储存数据数组的空间来储存当前后序遍历的结果。

     代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9.  
    10.  
    11. /**
    12.  * Note: The returned array must be malloced, assume caller calls free().
    13.  */
    14.  
    15.  void travel(struct TreeNode* root, int *num,int* returnSize)
    16. {
    17.     if(!root)
    18.         return;
    19.     travel(root->left,num,returnSize);
    20.     travel(root->right,num,returnSize);
    21.     num[*returnSize]=root->val;
    22.     *returnSize+=1;
    23. }
    24. int* postorderTraversal(struct TreeNode* root, int* returnSize){
    25.  
    26.     int *num=(int*)malloc(sizeof(int)*500);
    27.     *returnSize=0;
    28.     travel(root,num,returnSize);
    29.     return num;
    30. }


    7. 对称二叉树

    给你一个二叉树的根节点 root ， 检查它是否轴对称。

    思路分析：

    判断一个二叉树是否为对称二叉树也就是以根结点为对称轴进行划分比较，同样的分一些几种情况去讨论。1.如果此时对称位置的节点都为空，那么结果就是true；2.如果对称位置节点一个为空一个不为空，那结果就是false；3.如果对称位置节点的值不同，那结果也是false；4.最后就是如果对称位置的节点都存在而且里面的数据值也是相同的，那么就进行往下遍历，最后进行取和运算结果即可。

    代码实现：

    1. /**
    2.  * Definition for a binary tree node.
    3.  * struct TreeNode {
    4.  *     int val;
    5.  *     struct TreeNode *left;
    6.  *     struct TreeNode *right;
    7.  * };
    8.  */
    9.  
    10. bool check(struct TreeNode* p,struct TreeNode* q){
    11.     if(!p&&!q)
    12.         return true;
    13.     if(p==NULL||!q)
    14.         return false;
    15.     if(p->val!=q->val)
    16.         return false;
    17.     else
    18.         return check(p->left,q->right)&&check(p->right,q->left);
    19. }
    20. bool isSymmetric(struct TreeNode* root){
    21.     return check(root,root);
    22. }

     好了，以上就是本期习题的全部内容了，我们下一期再见！

     分享一张壁纸：

  • 相关阅读:
    PyCharm+Miniconda3安装配置教程
    NURBS曲线-节点插入（原理+代码）
    【Golang】简记操作：Centos安装、卸载、升级Golang运行环境
    MySQL同步数据到Elasticsearch
    iOS系统下轻松构建自动化数据收集流程
    ClickHouse进阶（十一）：Clickhouse数据字典-1
    EasyExcel使用实体类进行读操作和写操作
    基于SSM的车辆维修管理系统
    一文解决动态规划～详解
    vue七牛云视频直传
  • 原文地址：https://blog.csdn.net/m0_73633088/article/details/133442706