Day15｜二叉树part02：102. 二叉树的层次遍历等、226. 翻转二叉树、110. 平衡二叉树、101. 对称二叉树

于 2024-03-20 16:36:50 发布
阅读量1.1k 收藏 11
点赞数 23
分类专栏： 数据结构与算法（二刷） 文章标签： leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43303286/article/details/136881224
版权

102. 二叉树的层次遍历

没啥好说的，使用队列，这里注意java也使用deque进行模拟，这里总结下deque用法：

  • deque作为栈使用时：
    • 添加元素：使用 push 方法将元素添加到栈的顶部。例如，deque.push(node)。
    • 获取并移除元素：使用 pop 方法从栈的顶部获取并移除元素。例如，TreeNode node = deque.pop()。
    • 获取但不移除元素：使用 peek 方法从栈的顶部获取但不移除元素。例如，TreeNode node = deque.peek()。
    • 检查栈是否为空：使用 isEmpty 方法检查栈是否为空。例如，boolean isEmpty = deque.isEmpty()
  • deque作为队列使用时：
    • 添加元素：使用 add 或 offer 方法将元素添加到队列的末尾。例如，deque.add(node) 或 deque.offer(node)。
    • 获取并移除元素：使用 poll 方法从队列的头部获取并移除元素。例如，TreeNode node = deque.poll()。
    • 获取但不移除元素：使用 peek 方法从队列的头部获取但不移除元素。例如，TreeNode node = deque.peek()。
    • 检查队列是否为空：使用 isEmpty 方法检查队列是否为空。例如，boolean isEmpty = deque.isEmpty()。
class Solution {
    private List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            List<Integer> res1 = new ArrayList<>();
            for (int i = 0; i < len; i++){
                TreeNode p = deque.peek();
                res1.add(p.val);
                deque.poll();
                if(p.left != null){
                    deque.add(p.left);
                }
                if(p.right != null){
                    deque.add(p.right);
                }
            }
            res.add(res1);

        }
        return res;
    }
}
  • while的每次循环控制的是每一层，for循环则控制的该层的每个节点。

107.二叉树的层次遍历II

就是从下往上输出，这里把层序遍历的res数组按第一维度翻转即可：

class Solution {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        if (root == null) {
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int len = deque.size();
            List<Integer> res1 = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                TreeNode p = deque.peek();
                res1.add(p.val);
                deque.poll();
                if (p.left != null) {
                    deque.add(p.left);
                }
                if (p.right != null) {
                    deque.add(p.right);
                }
            }
            res.add(res1);

        }
        Collections.reverse(res);
        return res;
    }
}
  • Collections.reverse(res); 意思是把res翻转；

199. 二叉树的右视图

只把每一层的最后一个节点加入结果集即可。

class Solution {
      private List<Integer> res = new ArrayList<>();
      public List<Integer> rightSideView(TreeNode root) {
          if(root == null){
              return res;
          }
          Deque<TreeNode> deque = new LinkedList<>();
          deque.add(root);
          while(!deque.isEmpty()){
              int len = deque.size();
              for (int i = 0; i < len; i++){
                  TreeNode p = deque.peek();
                  deque.poll();
                  if(p.left != null){
                      deque.add(p.left);
                  }
                  if(p.right != null){
                      deque.add(p.right);
                  }
                  if(i == len - 1){
                      res.add(p.val);
                  }
              }

          }
          return res;
      }
  }
  • 这里注意res必须得new ArrayList()，不然会报错（和cpp不一样）

637. 二叉树的层平均值

class Solution {
    private List<Double> res = new ArrayList<>();
    public List<Double> averageOfLevels(TreeNode root) {
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            double sum = 0.0;
            for (int i = 0; i < len; i++){
                TreeNode p = deque.peek();
                sum += p.val;
                deque.poll();
                if(p.left != null){
                    deque.add(p.left);
                }
                if(p.right != null){
                    deque.add(p.right);
                }
            }
            res.add(sum / len);

        }
        return res;
    }
}

429. N叉树的层次遍历

把p.left p.right换成for循环遍历children数组。

class Solution {
    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(Node root) {
        if (root == null) {
            return res;
        }
        Deque<Node> deque = new LinkedList<>();
        deque.add(root);
        while (!deque.isEmpty()) {
            int len = deque.size();
            List<Integer> res1 = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                Node p = deque.peek();
                res1.add(p.val);
                deque.poll();
                for (int j = 0; j < p.children.size(); j++) {
                    if (p.children.get(j) != null) {
                        deque.add(p.children.get(j));
                    }
                }
            }
            res.add(res1);

        }
        return res;
    }
}

515.在每个树行中找最大值

跟求平均值那题一样的思路：

class Solution {
    private List<Integer> res = new ArrayList<>();
    public List<Integer> largestValues(TreeNode root) {
        if(root == null){
            return res;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            int max = Integer.MIN_VALUE;
            for (int i = 0; i < len; i++){
                TreeNode p = deque.peek();
                max = Math.max(max , p.val);
                deque.poll();
                if(p.left != null){
                    deque.add(p.left);
                }
                if(p.right != null){
                    deque.add(p.right);
                }
            }
            res.add(max);

        }
        return res;
    }
}
  • Integer.MIN_VALUE；就是取Integer中的最小值。

116.填充每个节点的下一个右侧节点指针

跟右视图那题一样，最后一个节点特殊处理，其他的练到poll后队列的头部。

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return null;
        }
        Deque<Node> deque = new LinkedList<>();

        deque.add(root);
        root.next = null;

        while(!deque.isEmpty()){
            int len = deque.size();
            for (int i = 0; i < len; i++) {
                Node p = deque.peek();
                deque.poll();

                p.next = deque.peek();

                if(i == len - 1){
                    p.next = null;
                }
                if(p.left != null){
                    deque.add(p.left);
                }
                if(p.right != null){
                    deque.add(p.right);
                }

            }


        }
        return root;
    }
}

117.填充每个节点的下一个右侧节点指针II

通过117.填充每个节点的下一个右侧节点指针II我们可以得到，即使不是完美二叉树也可使用上面的代码，因为在层序遍历中，以我们的上帝视角看，其实结构还是一样的，都处于同一层。

104.二叉树的最大深度

层序遍历：用一个depth变量记录遍历的层数：

class Solution {
  public int maxDepth(TreeNode root) {
      if (root == null) {
          return 0;
      }
      int depth = 0;
      Deque<TreeNode> deque = new LinkedList<>();
      deque.add(root);
      while (!deque.isEmpty()) {
          int len = deque.size();
          depth++;
          for (int i = 0; i < len; i++) {

              TreeNode p = deque.peek();
              deque.poll();
              if (p.left != null) {
                  deque.add(p.left);
              }
              if (p.right != null) {
                  deque.add(p.right);
              }
          }

      }
      return depth;
  }
}

111.二叉树的最小深度

一碰到叶子结点就停止输出：

class Solution {
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int depth = 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root);
        while(!deque.isEmpty()){
            int len = deque.size();
            depth++;
            List<Integer> res1 = new ArrayList<>();
            for (int i = 0; i < len; i++){
                TreeNode p = deque.peek();

                deque.poll();
                if(p.left == null && p.right == null){
                    return depth;
                }
                if(p.left != null){
                    deque.add(p.left);
                }
                if(p.right != null){
                    deque.add(p.right);
                }
            }

        }
        return depth;
    }

}

226.翻转二叉树

递归法：

class Solution {
    private TreeNode traversal(TreeNode node){
        if(node == null){
            return null;
        }
        TreeNode left = traversal(node.left);
        TreeNode right = traversal(node.right);

        node.left = right;
        node.right = left;

        return node;
    }
    public TreeNode invertTree(TreeNode root) {
        traversal(root);
        return root;
    }
}

迭代法：

   public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        if(root == null){
            return null;
        }
        deque.push(root);
        while(!deque.isEmpty()){
            TreeNode p = deque.peek();
            deque.pop();
            TreeNode tmp = p.right;
            p.right = p.left;
            p.left = tmp;
            if(p.right != null){
                deque.push(p.right);
            }
            if(p.left != null){
                deque.push(p.left);
            }
        }

        return root;
    }

110.平衡二叉树

  • 本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
  • 思路：递归求两个子树高度，一旦不满足平衡了，就把该节点的高度设置为-1；
  • 一旦子树中有-1，那么本身肯定不是二叉平衡树了，直接返回-1；
  • 如果还是，更新高度为Math.max(left, right) + 1;
class Solution {
    private int getHeight(TreeNode node){
        if(node == null){
            return 0;
        }
        int left = getHeight(node.left);
        if(left==-1){
            return -1;
        }
        int right = getHeight(node.right);
        if(right == -1){
            return -1;
        }
        if(Math.abs(left - right) > 1){
            return -1;
        }
        return Math.max(left, right) + 1;


    }
    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }

        return getHeight(root) != -1;
    }
}
  • 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
  • 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：

image

（高度：从下往上，深度：从上往下）

关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，leetcode的题目中都是以节点为一度，即根节点深度是1。但维基百科上定义用边为一度，即根节点的深度是0，我们暂时以leetcode为准（毕竟要在这上面刷题）。

101. 对称二叉树

  • 递归法：
class Solution {
    public boolean check(TreeNode left, TreeNode right){
        if(left == null && right == null) {
            return true;
        }else if(left == null || right == null){
            return false;
        }else if(left.val != right.val){
            return false;
        } else{
            return check(left.left, right.right) && check(left.right, right.left);
        }
    }
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }
}
  • else if(left.val != right.val){这个条件是我漏的，对左右树判断子树对称之前首先要判断当前节点的值是否相等。
  • 迭代法：
public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }

        Deque<TreeNode> deque = new LinkedList<>();
        deque.add(root.left);
        deque.add(root.right);

        while(!deque.isEmpty()){
            TreeNode p1 = deque.peek();
            deque.poll();
            TreeNode p2 = deque.peek();
            deque.poll();
            if(p1 == null && p2 == null){
                continue;
            }else if(p1 == null || p2 == null){
                return false;
            }else if(p1.val != p2.val){
                return false;
            }else{
                deque.add(p1.left);
                deque.add(p2.right);
                deque.add(p1.right);
                deque.add(p2.left);
            }

        }
        return true;
    }
  • 这里用栈也可以，这里用的是队列，只要有一个容器可以两两比较就可以了。
QHG7C0
关注
  • 23
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值