代码随想录训练营第十五天|102. 二叉树的层序遍历(十道层序遍历算法题) 104. 二叉树的最大深度 111. 二叉树的最小深度

于 2023-03-16 21:04:05 发布
阅读量186 收藏
点赞数
文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Fxxkke/article/details/129557502
版权

文章目录

102. 二叉树的层序遍历

102. 二叉树的层序遍历

/**
 * 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<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkfun(root);
        return resList;
        //使用迭代法（用一个队列来模拟），实现二叉树的层序遍历
        
    }
    public void checkfun (TreeNode node){
        if(node ==  null){
            return;
        }
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);
        while(!que.isEmpty()){
            //当队列非空的时候，则不断弹出队首node
            //在创建一个数组用来接收每一层的结果
            List<Integer> itemList = new ArrayList<Integer>();
            //取得队列中元素的个数
            int len = que.size();
            while(len > 0){
                TreeNode temp = que.poll();
                itemList.add(temp.val);
                if(temp.left!= null){
                    que.offer(temp.left);
                }
                if(temp.right!= null){
                    que.offer(temp.right);
                }
                len--;
            }
            resList.add(itemList);
        }
    }
}

107. 二叉树的层序遍历 II

107. 二叉树的层序遍历 II
本题和第一题较为类似，最后将每层的得到的数组再倒序一次即可

class Solution {
    //首先创建一个二维数组来存放最终的结果
    //在创建一个队列
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Deque<TreeNode> que = new LinkedList<>();
        List<List<Integer>> resList = new ArrayList<>();
        if(root == null){
            return resList;
        }
        
        //首先在队列中加入root节点
        que.offerLast(root);
        while(!que.isEmpty()){
            //再创建一个数组用来存放每层遍历的结果  **注意创建层序遍历存放的数组应该放在while循环中，每次都会创建一个新的层序遍历数组
            List<Integer> itemList = new ArrayList<>();
            int len = que.size();
             for (int i = 0; i < len; i++) {
                //当队列非空的时候
                TreeNode temp = que.peekFirst();
                itemList.add(que.pollFirst().val);
                if(temp.left != null){
                    que.offerLast(temp.left);
                }
                if(temp.right != null){
                    que.offerLast(temp.right);
                }
            }
            resList.add(itemList);
        }
         //现在resList中存在着正序的层序遍历结果，接下来要将这个二维数组翻转
         List<List<Integer>> result = new ArrayList<>();
         for(int i = resList.size()-1 ;i >= 0 ; i--){
             result.add(resList.get(i));
         }
         return result;
    }
   

}

199. 二叉树的右视图

199. 二叉树的右视图

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
        //创建一个队列和二维数组
        Deque<TreeNode> que = new LinkedList<>();
        List<Integer> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        que.offerLast(root);
        while(!que.isEmpty()){
            int levelSize = que.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode temp = que.pollFirst();
                if(temp.left != null){
                    que.addLast(temp.left);
                }
                if(temp.right != null){
                    que.addLast(temp.right);
                }
                if(i == levelSize - 1){
                    //通过i的值来判断是否是层序的最后一个
                    list.add(temp.val);
                }
            }
        }
        return list;
    }
}

637. 二叉树的层平均值

637. 二叉树的层平均值


class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Deque<TreeNode> que = new LinkedList<>();
        List<Double> list = new ArrayList<>();
        if(root == null){
            return list;
        }
        que.offerLast(root);
        while(!que.isEmpty()){
            int len = que.size();
            double sum = 0.0;
            for(int i = 0;i < len ; i++){
                TreeNode temp = que.pollFirst();
                //pollFirt?和pollLast?
                sum += temp.val;
                if(temp.left != null){ 
                    que.offerLast(temp.left);
                }
                if(temp.right != null){
                    que.offerLast(temp.right);
                }

            }
            list.add(sum / len);            
        }
        return list;
    }
}

429. N 叉树的层序遍历

429. N 叉树的层序遍历

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

   public Node() {}

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

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

class Solution {

   public List<List<Integer>> levelOrder(Node root) {
       //依旧是层序遍历，只不过孩子节点的个数变了
       List<List<Integer>> reslist = new ArrayList<>();
       Deque<Node> que = new LinkedList<>();
       if (root == null){
           return reslist;
       }
       que.offerLast(root);
       while(!que.isEmpty()){
           int len = que.size();
           //创建层序遍历数组
           List<Integer> list = new ArrayList<>();
           for(int i = 0; i < len; i++){
               Node temp = que.pollFirst();
               list.add(temp.val);
               //创建孩子节点的数组
               List<Node> children = temp.children;
               if (children == null || children.size() == 0) {
                   continue;
               }
               //将所有孩子节点加入到队列中
               for (Node child : children) {
                   if (child != null) {
                       que.offerLast(child);
                   }
               }
           }
           reslist.add(list);    
       }
        return reslist;
   }
}

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

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

/**
* 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> largestValues(TreeNode root) {
       //层序遍历，取每一层的最大值
        if(root == null){
           return Collections.emptyList();
       }
       List<Integer> result = new ArrayList();
       Queue<TreeNode> 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;
   }
}

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

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

/*
// Definition for a Node.
class Node {
   public int val;
   public Node left;
   public Node right;
   public Node next;

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

   public Node(int _val, Node _left, Node _right, Node _next) {
       val = _val;
       left = _left;
       right = _right;
       next = _next;
   }
};
*/

class Solution {
   public Node connect(Node root) {
       if (root == null) {
           return root;
       }
       
       // 初始化队列同时将第一层节点加入队列中，即根节点
       Queue<Node> queue = new LinkedList<Node>(); 
       queue.add(root);
       
       // 外层的 while 循环迭代的是层数
       while (!queue.isEmpty()) {
           
           // 记录当前队列大小
           int size = queue.size();
           
           // 遍历这一层的所有节点
           for (int i = 0; i < size; i++) {
               
               // 从队首取出元素
               Node node = queue.poll();
               
               // 连接
               if (i < size - 1) {
                   node.next = queue.peek();
               }
               
               // 拓展下一层节点
               if (node.left != null) {
                   queue.add(node.left);
               }
               if (node.right != null) {
                   queue.add(node.right);
               }
           }
       }
       
       // 返回根节点
       return root;
   }
}

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

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

/*
// Definition for a Node.
class Node {
   public int val;
   public Node left;
   public Node right;
   public Node next;

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

   public Node(int _val, Node _left, Node _right, Node _next) {
       val = _val;
       left = _left;
       right = _right;
       next = _next;
   }
};
*/

class Solution {
   public Node connect(Node root) {
       //本题和116完全二叉树的填充右侧节点有相似之处
       Queue<Node> que = new LinkedList<>();
       if(root != null){
           que.add(root);
       }
       while(!que.isEmpty()){
           int size = que.size();
           //创建两个指针
           Node prenode = null;
           Node node = null;
           for(int i = 0 ; i < size ; i ++){
               if(i == 0){
                   node = que.poll();
                   prenode = node;
               }
               else {
                   node = que.poll();
                   prenode.next = node;
                   prenode = node;
               }
               if(node.left != null){
                   que.add(node.left);
               }
               if(node.right != null){
                   que.add(node.right);
               }
           }
           prenode.next = null;
       }
       return root;
   }
}

104. 二叉树的最大深度

104. 二叉树的最大深度

/**
 * 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) {
        //使用层序遍历来求解
        Queue<TreeNode> que = new LinkedList<>();
        if(root == null){
            return 0;
        }
        que.offer(root);
        int depth = 0;
        while(!que.isEmpty()){
            int len = que.size();
            while(len > 0){
                TreeNode temp = que.poll();
                if(temp.left != null){
                    que.offer(temp.left);
                }
                if(temp.right != null){
                    que.offer(temp.right);
                }
                len--;
            }
            depth++;
        }
        return depth;
    }
}

方法2：迭代处理

class Solution {
public:
    int maxDepth(TreeNode* root) {
        //二叉树的题有两种思路，1是遍历二叉树，2是将分体分解成小问题，迭代处理
       //此次采用第二种方法，分解问题的方式
       if(root==nullptr){
           return 0;
       }
       //设定一个函数，输入二叉树，返回最大深度
       int left=maxDepth(root->left);
       int right=maxDepth(root->right);
       int res = max(left,right)+1;
       return res;
    }
    
};

111. 二叉树的最小深度

[111. 二叉树的最小深度](ht tps://leetcode.cn/problems/minimum-depth-of-binary-tree/)

class Solution {
    public int minDepth(TreeNode root){
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while (!queue.isEmpty()){
            int size = queue.size();
            depth++;
            TreeNode cur = null;
            for (int i = 0; i < size; i++) {
                cur = queue.poll();
                //如果当前节点的左右孩子都为空，直接返回最小深度
                if (cur.left == null && cur.right == null){
                    return depth;
                }
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
        }
        return depth;
    }
}
Fxxkke
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值