算法训练营Day14

#Java #二叉树层次遍历 #反转二叉树

开源学习资料

二叉树的层次遍历:力扣题目链接

二叉树的层次遍历很好理解:

就是从根结点一层一层地往下遍历(同一层,从左到右):

算法训练营Day14_第1张图片

迭代的方式很好理解:就是依次入队出队。

但是判断条件怎么写?

最需要解决的就是,要把节点依次入队,那要怎么记录这些节点,防止它们丢失。

第一步把根节点先入队,这时候要想让它的左孩子和右孩子入队(如上图),就要在A出队的时候,记录它。

关键的就是在一个节点出队的时候,记录该节点,就能找到它的左右孩子。

/**
 * 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> res = new ArrayList<>();
    public List> levelOrder(TreeNode root) {
        if(root == null){
            return res;
        }
    //模拟成一个队列
    //从根节点开始,依次入队(从左到右)
    Queue queue = new LinkedList<>(); //创建一个队列
  
    //根节点先入队
    queue.offer(root);
    while(!queue.isEmpty()){
        int len = queue.size();
          List list  = new ArrayList<>();
        while(len>0){
        //记录出队的节点
        TreeNode node = queue.poll();
        list.add(node.val);
        if(node.left!=null){
            //左孩子入队
            queue.offer(node.left);
        }
        if(node.right!=null){
            //右孩子入队
            queue.offer(node.right);
        }
        len--;
    }
    res.add(list);
    }
    return res;
    }
}

用两个while循环,主要是为了满足结果形式,保证每个结果都保存在一个新的集合中。

不然就是这样的(结果不能反映出是层次遍历)

算法训练营Day14_第2张图片

先使用DFS迭代遍历练习以下题目:

二叉树的层序遍历II:力扣题目链接

给你二叉树的根节点 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 {
     List> res = new LinkedList<>();
    public List> levelOrderBottom(TreeNode root) {
       Queue que = new LinkedList<>();
       if(root == null){
           return res;
       }
       //先把根节点入队
       que.offer(root);
       while(!que.isEmpty()){
           List list = new ArrayList<>();
           int size = que.size();
           //每一层入队出队
           for(int i =0;i

思路相同,只是用了链表的翻转。

二叉树的右视图:力扣题目链接

给定一个二叉树的 根节点 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 List rightSideView(TreeNode root) {
        List list = new ArrayList<>();
        Deque que = new LinkedList<>();

        if (root == null) {
            return list;
        }

        que.offer(root);
        while (!que.isEmpty()) {
            int levelSize = que.size();

            for (int i = 0; i < levelSize; i++) {
                TreeNode node = que.poll();

                if (node.left != null) {
                    que.offer(node.left);
                }
                if (node.right != null) {
                    que.offer(node.right);
                }
                //就多一步:
                //只要最右边的:
                if (i == levelSize - 1) {
                    list.add(node.val);
                }
            }
        }

        return list;
    }
}

 这道题就关键的一步:只把最右边的放到结果中!

二叉树的层平均值:力扣题目链接

给定一个非空二叉树的根节点 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 List averageOfLevels(TreeNode root) {
        List list = new ArrayList<>();
    Queue que = new LinkedList<>();
    if(root==null){
        return list;
    }
    que.offer(root);
    while(!que.isEmpty()){
        int size = que.size();
        Double sum =0.0;
        for(int i =0 ;i

一层一层计算 !

 N叉树的层序遍历:力扣题目链接

给定一个 N 叉树,返回其节点值的层序遍历。 (即从左到右,逐层遍历)。 

/*
// Definition for a Node.
class Node {
    public int val;
    public List children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List> levelOrder(Node root) {
        if (root == null) {
            return new ArrayList>();
        }

        List> ans = new ArrayList>();
        Queue queue = new ArrayDeque();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int cnt = queue.size();
            List level = new ArrayList();
            for (int i = 0; i < cnt; ++i) {
                Node cur = queue.poll();
                level.add(cur.val);
                for (Node child : cur.children) {
                    queue.offer(child);
                }
            }
            ans.add(level);
        }

        return ans;
    }
}

在每个树行中找最大值:力扣题目链接

您需要在二叉树的每一行中找到最大的值。

/**
 * 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 largestValues(TreeNode root) {
        if(root == null){
            return Collections.emptyList();
        }
        List result = new ArrayList();
        Queue queue = new LinkedList();
        queue.offer(root);
        while(!queue.isEmpty()){
            int max = Integer.MIN_VALUE;
            for(int i = queue.size(); i > 0; i--){
               TreeNode node = queue.poll();
               max = Math.max(max, node.val);
               if(node.left != null) queue.offer(node.left);
               if(node.right != null) queue.offer(node.right);
            }
            result.add(max);
        }
        return result;
    }
}

二叉树的最大深度:力扣题目链接

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

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

class Solution {
    public int maxDepth(TreeNode root) {
      if (root == null)   return 0;
   //先创建一个队列
    Queue que = new LinkedList<>();
    //利用层次遍历
    //加入节点
    que.offer(root);
    int deep =0;
    while(!que.isEmpty()){
        int len = que.size();
        while(len>0){
         TreeNode node = que.poll();
         if(node.left!=null) que.offer(node.left);
         if(node.right!=null) que.offer(node.right);
         len--;
        }
         deep++;
    }
      return deep;
    }
}

二叉树的最小深度 :力扣题目链接

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

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

/**
 * 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) {
    Queue que = new LinkedList<>();
    if(root == null){
        return 0;
    }
    que.offer(root);
    int deep=0;
    while(!que.isEmpty()){
        int size = que.size();
        deep++;
        for(int i =0;i

利用层序遍历快速刷完了这几道题,发现基本都是一个模板,只是根据每一个题的要求作出一些改变,大体上还是一模一样的。

体会:在外层while中执行的就是当前位置要做的事情,而内层的for循环/while循环,就为下一层做好准备,而size则是控制每层中的节点。

翻转二叉树:力扣题目链接

翻转一棵二叉树。

力扣示例:

算法训练营Day14_第3张图片

这道题用递归来写:

/**
 * 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;
    }
    invertTree(root.left);
    invertTree(root.right);
    swap(root);
    return root;
    }

    //交换的方法
    public void swap(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

代码很简单,但是要深刻理解递归!

1.递归的出口

2.方法的返回值

当 root 为 null 时,递归的出口就是返回 null。这是因为在二叉树的递归操作中,每个递归步骤都涉及到对左右子树的处理,而 null 表示一个空节点或者叶子节点的空子树。

在这个具体的情境中,当 invertTree 方法递归到叶子节点的左右子树时,这些子树是空的,因此将它们反转后仍然为空。返回 null 可以告诉上一级递归调用,这个空节点的左右子树已经反转完成。

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 boolean isSymmetric(TreeNode root) {
    if(root == null){
        return true;
    }
    return dfs(root.left,root.right);
    }

    boolean dfs(TreeNode left , TreeNode right){
        //递归结束条件:
        //左右子树都为空
        if(left == null && right ==null){
            return true;
        }
        //左右节点有一个为空
        if(left == null || right == null){
            return false;
        }
         //左右节点的值不相等
        if(left.val != right.val){
            return false;
        }
        return dfs(left.left,right.right) && dfs(left.right,right.left);
    }
}

这些都是比较简单的递归,思想主要是抓住:

方法的返回值

递归的终止条件

确定递归的单层逻辑

在代码随想录中有对这三部曲的详细概括!即时Review~~~~

我自光芒万丈,

何须他人半点光!

Fighting!

你可能感兴趣的:(算法)