树的层次遍历相关leetcode_树的层析序列-CSDN博客

本文链接：https://blog.csdn.net/Prayer96/article/details/115420776

树的层次遍历相关leetcode

No.102 二叉树的层序遍历

思路：创建一个list类型的result接收最后的结果。创建一个队列，将每一层的元素入队。先将根节点入队，while循环队列不为空，计算队列的长度size，循环判断size>0，依次出队size个元素直到size等于0，依次将出队的元素存入list类型的临时变量list中，然后将list加入到result中。返回result。

/**
 * 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>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            while(size > 0) {
                TreeNode top = queue.poll();
                list.add(top.val);
                if(top.left != null) {
                    queue.add(top.left);
                }
                if(top.right != null) {
                    queue.add(top.right);
                }
                size--;
            }
            result.add(list);
        }
        return result;
    }
}

No.107 二叉树的层序遍历2

思路：和上一题的一样，但是这题的层次遍历是从下到上的层次遍历，所以最后输出的result需要使用Collections.reverse方法倒序排列以下再返回。

/**
 * 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>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            while(size > 0) {
                TreeNode top = queue.poll();
                list.add(top.val);
                if(top.left != null) {
                    queue.add(top.left);
                }
                if(top.right != null) {
                    queue.add(top.right);
                }
                size--;
            }
            result.add(list);
        }
        Collections.reverse(result);
        return result;
    }
}

No.199 二叉树的右视图

思路：也是进行二叉树的层次遍历，在遍历每一层的时候，判断当前出队的元素是否是这一层的最后一个元素，也就是当前元素出队后，队列的长度是否为0。

/**
 * 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> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            while(size > 0) {
                TreeNode top = queue.poll();
                if(top.left != null) {
                    queue.add(top.left);
                }
                if(top.right != null) {
                    queue.add(top.right);
                }
                size--;
                if(size == 0) {
                    result.add(top.val);
                }
            }
        }
        return result;
    }
}

No.637 二叉树的层平均值

思路：也是进行二叉树的层次遍历，定义一个double变量sum，在遍历每一层的每一个元素时，将当前元素值加到sum中，遍历完每一层之后，将sum除以每一层的元素数，也就是队列的长度，将商加入到result中。

/**
 * 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<Double> averageOfLevels(TreeNode root) {
        List<Double> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            double sum = 0;
            int size = queue.size();
            int count = size;
            while(size > 0) {
                TreeNode top = queue.poll();
                sum += top.val;
                if(top.left != null) {
                    queue.add(top.left);
                }
                if(top.right != null) {
                    queue.add(top.right);
                }
                size--;
            }
            result.add(sum / count);
        }
        return result;
    }
}

No.429 N叉树的层序遍历

思路：也是进行二叉树的层次遍历，和102代码类似，只是将节点的左右孩子入队改为了将节点的孩子list入队。

/*
// 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>> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            while(size > 0) {
                Node top = queue.poll();
                list.add(top.val);
                if(top.children != null) {
                    for(Node child : top.children) {
                        queue.add(child);
                    }
                }
                size--;
            }
            result.add(list);
        }
        return result;
    }
}

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

思路：也是进行二叉树的层次遍历，在遍历每一层的时候，定义一个max变量，初始值为Integer.MIN_VALUE，记录该层的最大值。每出队一个元素，将其值与max相比，将较大值赋值给max，遍历完每一层之后，将max加入到result中。

/**
 * 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) {
        List<Integer> result = new ArrayList<>();
        if(root == null)
            return result;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int max = Integer.MIN_VALUE;
            int size = queue.size();
            while(size > 0) {
                TreeNode top = queue.poll();
                max = max > top.val ? max : top.val;
                if(top.left != null) {
                    queue.add(top.left);
                }
                if(top.right != null) {
                    queue.add(top.right);
                }
                size--;
            }
            result.add(max);
        }
        return result;
    }
}

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

思路：也是进行二叉树的层次遍历，在遍历每一层的时候，创建一个节点pre记录当前节点的上一个节点，每个节点出队后，将pre的next指向该节点，然后将pre更新为该节点。因为是完美二叉树，要么节点的左右节点均不为空，要么左右节点均为空。当均不为空时，将左节点的next指向右节点，将右节点的next指向null，并将左右节点入队。

/*
// 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<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            Node pre = new Node();
            while(size > 0) {
                Node top = queue.poll();
                pre.next = top;
                if(top.left != null && top.right != null) {
                    top.left.next = top.right;
                    top.right.next = null;
                    queue.add(top.left);
                    queue.add(top.right);
                }
                pre = top;
                size--;
            }
        }
        return root;
    }
}

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

思路：也是进行二叉树的层次遍历，和上一题的代码类似，但是这题是普通二叉树，节点的左右节点可能都存在，可以存在其中一个，可能都不存在。所以要对当前出队节点是否存在左右节点进行判断，如果都存在，则将左节点的next指向右节点，右节点的next指向null，并将左右节点入队；如果左节点存在，右节点不存在，将左节点的next指向null，左节点入队；如果左节点不存在，右节点存在，将右节点的next指向null，右节点入队。

/*
// 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<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            Node pre = new Node();
            while(size > 0) {
                Node top = queue.poll();
                pre.next = top;
                if(top.left != null && top.right != null) {
                    top.left.next = top.right;
                    top.right.next = null;
                    queue.add(top.left);
                    queue.add(top.right);
                }
                if(top.left != null && top.right == null) {
                    top.left.next = null;
                    queue.add(top.left);
                }
                if(top.right != null && top.left == null) {
                    top.right.next = null;
                    queue.add(top.right);
                }
                pre = top;
                size--;
            }
        }
        return root;
    }
}