第六章二叉树part02 层序遍历

没有人能随随便便成功

已于 2023-10-03 08:59:40 修改

阅读量34

点赞数

文章标签： windows

于 2023-10-01 14:43:25 首次发布

本文链接：https://blog.csdn.net/qq_39072888/article/details/133461341

版权

递归方式层序遍历

class Solution {
   List<List<Integer>> levels = new ArrayList<>();
    public void helper(TreeNode node, int level){
        if(levels.size() == level){
            levels.add(new ArrayList<Integer>());
        }
        levels.get(level).add(node.val);
        if(node.left != null)
            helper(node.left,level+1);
        if(node.right != null)    
            helper(node.right,level+1);


    }
    public List<List<Integer>> levelOrder(TreeNode root) {
        
        if(root == null) return levels;
        helper(root,0);
        return  levels;
    }
}

本种解法，利用到了ArrayList存储了一些List<Integer>，每个list就是每一层，其中有一层的所有元素，精髓的就是，levels.get(level).add(node.val)

迭代方式层序遍历

class Solution {
    List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public void helper(TreeNode node){
        Deque<TreeNode> dq = new LinkedList<TreeNode>();
        if(node == null) return;
        dq.offer(node);
        
        while(!dq.isEmpty()){
            int len = dq.size();
            List<Integer> list = new ArrayList<>();
            while(len!= 0){
                TreeNode tempNode = dq.poll();
                
                list.add(tempNode.val);
                if(tempNode.left != null) dq.offer(tempNode.left);
                if(tempNode.right != null) dq.offer(tempNode.right);
                
                len--;
                }
                resList.add(list);
        }
    }
    public List<List<Integer>> levelOrder(TreeNode root) {
        helper(root);
        return resList;
    }
}

重点是要想清楚，队列中每次弹出以后都要加入子节点的话，怎么才算遍历完一层，那么解决办法就是每次遍历完一层先进行队列的size取值知道size有多少后赋值给一个控制循环的变量，这样在poll对应的元素之后就返回一个List<Integer> 这个就要加入到大的List<List<Integer>>中去，这样就是一层了

107 层序遍历II

重点是知道add(int index, element) 这个方法，就是在指定位置插入元素，题目要求是从下往上遍历，那么就在resList中一直在0这个位置插入元素，遍历顺序还是从上往下遍历，但是插入结果列表中时是一直在0的位置插入就成从下往上遍历列表了

class Solution {
    List<List<Integer>> resList = new ArrayList<>();
    Deque<TreeNode> dq = new LinkedList<>();
    public void helper(TreeNode node){
        if(node == null)return;
        dq.offer(node);
        
        while(!dq.isEmpty()){
            int len = dq.size();
            List<Integer> list = new ArrayList<>();
            while(len > 0){
                TreeNode tempNode = dq.poll();
                list.add(tempNode.val);
                if(tempNode.left != null)
                    dq.offer(tempNode.left);
                if(tempNode.right != null)
                    dq.offer(tempNode.right);
                len--;
            }
            resList.add(0,list);
        }
        
        
    }
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        helper(root);
        return resList;
        
    }
}

199二叉树右视图

class Solution {
    Deque<TreeNode> curLevel = new ArrayDeque<>();
    Deque<TreeNode> nextLevel = new ArrayDeque<>();
   
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
        TreeNode tempNode = null;
        
        if(root == null)return res;
        nextLevel.offer(root);
        while(!nextLevel.isEmpty()){
            curLevel = nextLevel;
            nextLevel = new ArrayDeque<>();
            while(!curLevel.isEmpty()){
                tempNode = curLevel.poll();
                if(tempNode.left!=null)
                    nextLevel.offer(tempNode.left);
                if(tempNode.right!=null)
                    nextLevel.offer(tempNode.right);
            }
            res.add(tempNode.val);


        }
        return res;
        
    }
}

637二叉树层平均值

class Solution {
    Deque<TreeNode> dq = new ArrayDeque<>();
    List<Double> res = new ArrayList<>();
    TreeNode tempNode = null;
    public List<Double> averageOfLevels(TreeNode root) {
        if(root == null)return res;
        dq.offer(root);
        double len = 0;
        double sum = 0;
        while(!dq.isEmpty()){
            len = dq.size();   //重置该层size
            double devise = len;
            sum = 0;  //重置sum
            while(len > 0){
                
                tempNode = dq.poll();
                if(tempNode.left != null)
                    dq.offer(tempNode.left);
                if(tempNode.right != null)
                    dq.offer(tempNode.right);
                sum += tempNode.val;
                len--;

            }
            res.add(sum/devise);


        }
        return res;
    }
}

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 {
    List<List<Integer>> res = new ArrayList<>();
    Deque<Node> dq = new ArrayDeque<>();
    int levelsize = 0;
    public List<List<Integer>> levelOrder(Node root) {
        if(root == null)return res;
        dq.offerLast(root);
        while(!dq.isEmpty()){
           List<Integer> levelList = new ArrayList<>();
           levelsize = dq.size();
           for(int i = 0; i < levelsize; i++){       
                Node tempNode = dq.pollFirst();
                levelList.add(tempNode.val);
                
           if(tempNode.children == null || tempNode.children.size() == 0){
               continue;
           }
           List<Node> childrenList = new ArrayList<>();
           childrenList = tempNode.children;
           for(Node node : childrenList){
               if(node != null){
                   dq.offerLast(node);
               }
           }

           }
           res.add(levelList);


        }
        return res;
    }
}

核心是新建一个list<Node>存储 tempNode的children列表，然后用迭代器for(Node child : childrenList)来遍历每一个子节点。

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

class Solution {
    Deque<Node> dq = new ArrayDeque<>();
    
    public Node connect(Node root) {
        if(root == null)return root;
        dq.offer(root);
        int levelSize = 0;
        while(!dq.isEmpty()){
            levelSize = dq.size();
            Node cur = dq.poll();
            if(cur.left != null)
                dq.offer(cur.left);
            if(cur.right != null)
                dq.offer(cur.right);
            for(int index = 1; index < levelSize; index++){
                Node next = dq.poll();
                if(next.left != null)
                    dq.offer(next.left);
                if(next.right != null)
                    dq.offer(next.right);
                cur.next = next;
                cur = next;
            }
            

        }
        return root;
    }
}

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

同上

104 二叉树的最大深度

class Solution {
    Deque<TreeNode> dq = new ArrayDeque<>();
    int depth = 0;
    int levelSize = 0;
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        dq.offer(root);
        while(!dq.isEmpty()){
            levelSize = dq.size();
            for(int i = 0; i < levelSize ; i++){
                TreeNode tempNode = dq.poll();
                if(tempNode.left != null)
                    dq.offer(tempNode.left);
                if(tempNode.right != null)
                    dq.offer(tempNode.right);
            }
            depth++;


        }
        return depth;
    }
}

111 二叉树最小深度

class Solution {
    Deque<TreeNode> dq = new ArrayDeque<>();
    int depth = 0;

    public int minDepth(TreeNode root) {
        if(root == null)return 0;
        dq.offer(root);
        int levelSize = 0;
        while(!dq.isEmpty()){
            levelSize = dq.size();
            depth++;
            for(int i = 0; i < levelSize ; i++){
                TreeNode tempNode = dq.poll();
                if(tempNode.left == null && tempNode.right == null){
                    return depth;
                }
                if(tempNode.left!=null)
                    dq.offer(tempNode.left);
                if(tempNode.right!=null)
                    dq.offer(tempNode.right);
                
            }
        }
        return depth;

    }
}