0
0

《经典算法题》二叉树基础(二)

前言:

二叉树的题目绝大多数都可以利用递归来解决，熟练掌握二叉树的前中后序遍历以及层序遍历是能快速解决二叉树题目的基础。

一：判断完全二叉树

💡：判断一颗二叉树是完全二叉树.(拓展题非力扣)

1.1:思路

🔑：完全二叉树的定义:除最后一层外，其它层为全满结构，且最后一层的节点全部集中在

左边（即最后一层是从左到右渐满的结构）。

解法一：

** **判断完全二叉树的条件：

** （1):存在节点有右孩子但无左孩子，则一定不是完全二叉树**

** (2):在层序遍历中，遇到叶子节点后，后边遇到的所有节点均是叶子节点，如上图**

F节点是叶子节点，则G,H,I,J全是叶子节点。如果遇到了叶子节点，后面还有非叶子节点，则一定

不是完全二叉树。

1.2：代码

  1.     //给你一个二叉树，请判断其是否为完全二叉树
  2.     //判断规则两条
  3.     //1:如果遇到有右孩子，无左孩子的一定不是完全二叉树
  4.     //2:如果遇到了左右不双全的节点（即：没有左孩子和右孩子的节点）,则之后的所有点，都是叶子节点
  5.    public static class TreeNode{
  6.         public int val;
  7.         public TreeNode left;
  8.         public TreeNode right;
  9.         public  TreeNode(int val){
  10.             this.val=val;
  11.         }
  12.     }
  13.     public static boolean isCBT(TreeNode root){
  14.         //默认空树是完全二叉树
  15.         if(root==null){
  16.             return true;
  17.         }
  18.         //基于宽度优先遍历的判断规则
  19.         Queue<TreeNode> queue=new LinkedList<>();
  20.         TreeNode left=null;
  21.         TreeNode right=null;
  22.         boolean isMeet=false;//是否遇到了叶子节点
  23.         queue.add(root);
  24.         while(!queue.isEmpty()){
  25.             TreeNode cur=queue.poll();
  26.             left=cur.left;
  27.             right=cur.right;
  28.             if((right!=null&&left==null)||(isMeet&&left!=null)){
  29.                 return false;
  30.             }
  31.             //设置好isMeet
  32.             isMeet=left==null;
  33.             if(left!=null){
  34.                 queue.add(left);
  35.             }
  36.             if(right!=null){
  37.                 queue.add(right);
  38.             }
  39.         }
  40.         return true;
  41.     }

解法二：

💡：回顾一下完全二叉树的定义，除最后一层外，其它层属于全满结构，最后一层的节点全部集中在左侧，因此我们可以分类讨论最后一层节点的情况。

情况一：A的左子树是完全二叉树，A的右子树是满二叉树，且左子树高度=右子树高度+1

情况二：A的左子树是满二叉树，A的右子树是完全二叉树，且左子树高度=右子树高度+1

情况三：A的左子树是满二叉树，A的右子树是完全二叉树，且左子树高度=右子树高度

情况四：A的左子树是满二叉树，A的右子树是满二叉树，且左子树高度=右子树高度

1.3代码：

  1.     public static class TreeNode{
  2.         public int val;
  3.         public TreeNode left;
  4.         public TreeNode right;
  5.         public TreeNode(int val){
  6.             this.val=val;
  7.         }
  8.     }
  9.     //完全二叉树的定义：除最后一层之外其它层为全满
  10.     //最后一层为从左到右渐满的结构
  11.     public static class Info{
  12.         public boolean isFBT;
  13.         public boolean isCBT;
  14.         public int height;
  15.         public Info(boolean a,boolean b,int c){
  16.             isFBT=a;
  17.             isCBT=b;
  18.             height=c;
  19.         }
  20.     }
  21.     public static boolean isCBT(TreeNode root ){
  22.         return process(root).isCBT;
  23.     }
  24.     public static Info process(TreeNode node){
  25.         //base case
  26.         if(node==null){
  27.             return new Info(true,true,0);
  28.         }
  29.         Info leftInfo=process(node.left);
  30.         Info rightInfo=process(node.right);
  31.         //高度为左子树高度和右子树高度的较大者+1
  32.         int height=Math.max(leftInfo.height, rightInfo.height)+1;
  33.         //满二叉树的条件:左子树是满二叉树，右子树是满二叉树，左子树高度=右子树高度
  34.         boolean isFBT= leftInfo.isFBT&& rightInfo.isFBT&&leftInfo.height== rightInfo.height;
  35.         boolean isCBT=false;
  36.         if(isFBT){
  37.             isCBT=true;
  38.         }
  39.         else if(leftInfo.isCBT&& rightInfo.isFBT&&(leftInfo.height== rightInfo.height+1)){
  40.             isCBT=true;
  41.         }
  42.         else if(leftInfo.isFBT&& rightInfo.isFBT&&(leftInfo.height== rightInfo.height+1)){
  43.             isCBT=true;
  44.         }
  45.         else if(leftInfo.isFBT&& rightInfo.isCBT&&(leftInfo.height== rightInfo.height)){
  46.             isCBT=true;
  47.         }
  48.         return new Info(isFBT,isCBT,height);
  49.     }

二：二叉树的最大宽度

题目：求二叉树的最大宽度，即节点最多的层的节点数目

2.1：思路

💡：利用层序遍历，统计每一层的节点数目

2.2: 代码1

  1.     //求二叉树所有层中，节点个数最多层的节点数
  2.     //二叉树的bfs的应用 下面写三种解法
  3.     public static class TreeNode{
  4.         public int val;
  5.         public TreeNode left;
  6.         public TreeNode right;
  7.         public TreeNode(int val){
  8.             this.val=val;
  9.         }
  10.     }
  11.     public static int maxWidth(TreeNode root){
  12.         if(root==null){
  13.             return 0;
  14.         }
  15.         Queue<TreeNode> queue=new LinkedList<>();
  16.         queue.add(root);
  17.         //层序遍历会在遍历上一层的时候将下一层逐渐加入队列中
  18.         //这个过程队列中既有上一层节点也有下一层节点
  19.         //当上一层彻底遍历结束的时候，队列中就只有下一层的节点
  20.         int maxWidth=0;
  21.         while(!queue.isEmpty()){
  22.             int size=queue.size();
  23.             maxWidth=Math.max(maxWidth,size);
  24.             for(int i=0;i<size;i++){
  25.                 TreeNode cur=queue.poll();
  26.                 if(cur.left!=null){
  27.                     queue.add(cur.left);
  28.                 }
  29.                 if(cur.right!=null){
  30.                     queue.add(cur.right);
  31.                 }
  32.             }
  33.         }
  34.         return maxWidth;
  35.     }

2.2:代码2

💡：我们可以用变量来标记当前层的最后节点，这样我们遍历的时候就能区分每一层。

  1.     //方法二：在统计每一层的时候，刷新每一层的结束位置
  2.     public static int maxWidth2(TreeNode head){
  3.         if(head==null){
  4.             return 0;
  5.         }
  6.         Queue<TreeNode> queue=new LinkedList<>();
  7.         queue.add(head);
  8.         int maxWidth=0;
  9.         TreeNode curEnd=head;//当前层的最后节点
  10.         //在遍历当前层的时候，动态刷新出下一层的最后节点
  11.         //当当前遍历到的节点是当前层的最后节点时，做一次总结
  12.         TreeNode nextEnd=null;
  13.         int curLevelNodes=0;
  14.         while(!queue.isEmpty()){
  15.             TreeNode cur=queue.poll();
  16.             curLevelNodes++;
  17.             if(cur.left!=null){
  18.                 nextEnd=cur.left;
  19.                 queue.add(cur.left);
  20.             }
  21.             if(cur.right!=null){
  22.                 nextEnd=cur.right;
  23.                 queue.add(cur.right);
  24.             }
  25.             //检查一次
  26.             if(cur==curEnd){
  27.                 maxWidth=Math.max(maxWidth,curLevelNodes);
  28.                 curLevelNodes=0;
  29.                 curEnd=nextEnd;
  30.             }
  31.         }
  32.         return maxWidth;
  33.     }

三：二叉树的最大距离

题目：二叉树中任意两节点间都会有一个距离，该距离就是由一个节点到另一个节点的路径上的节点个数。

3.1：思路

💡：在以x为头的二叉树中，有三种情况

1) 最大距离在x的左子树上

2)最大距离在x的右子树上

3)最大距离经过x节点，是左子树的高度+右子树的高度+1

以x为头整颗树的最大高度是这三种情况的最大值

3.2:代码

  1.     public static class TreeNode{
  2.         public int val;
  3.         public TreeNode left;
  4.         public TreeNode right;
  5.         public TreeNode(int val){
  6.             this.val=val;
  7.         }
  8.     }
  9.     public static class Info{
  10.         public int maxDistance;
  11.         public int height;
  12.         public Info(int maxDistance,int height){
  13.             this.maxDistance=maxDistance;
  14.             this.height=height;
  15.         }
  16.     }
  17.     public static Info process(TreeNode node){
  18.         //base case
  19.         if(node==null){
  20.             return new Info(0,0);
  21.         }
  22.         Info leftInfo=process(node.left);
  23.         Info rightInfo=process(node.right);
  24.         int height=Math.max(leftInfo.height,rightInfo.height)+1;
  25.         int maxDistance=Math.max(
  26.                 Math.max(leftInfo.maxDistance, rightInfo.maxDistance),
  27.                 rightInfo.height+ rightInfo.height+1
  28.         );
  29.         return new Info(maxDistance,height);
  30.     }
  31.     public static int maxDistance(TreeNode root){
  32.         return process(root).maxDistance;
  33.     }

由于本人水平十分有限，若有错误请即使告知！如果有帮助别忘了

点赞👍 收藏✨ 关注✌

标签： leetcode 算法 面试
本文转载自: https://blog.csdn.net/ai15013602354/article/details/122781643
版权归原作者 快乐的星球 所有， 如有侵权，请联系我们删除。
登录后发布评论

“《经典算法题》二叉树基础(二)”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？