【剑指offer】32.2 从上到下打印二叉树2

题目描述

// 力扣
// 从上到下按层打印二叉树，同一层的节点按从左到右
// 的顺序打印，每一层打印到一行。

// 牛客
// 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

题解

// 本题最重要是需要将不同层之间分离出来
// 因此不能像《32.1 从上到下打印二叉树》一样每次结点出队就直接左右子树入队

//////////////////////////////// 队列分割 ///////////////////////////
// 队列分割，不是最好的方法，但是比较好理解
// 创建两个队列，一个队列q_cur用于上一层的结点出队，
// 另一个队列q_next用于保存下一层的结点。q_cur全部出队，则
// q_next结点给q_cur，重复操作。


// 力扣
// 执行用时：1 ms, 在所有 Java 提交中击败了92.86%的用户
// 内存消耗：38.4 MB, 在所有 Java 提交中击败了88.06%的用户
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.ArrayList;
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
		// 注意这里的初始化数据类型直接new ArrayList<List<Integer>>()就行
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null)
            return res;
        // 构建两个队列，队列用链表模拟，
		// q_cur用于存当前层的结点遍历,q_next用于下一层结点的存储
		LinkedList<TreeNode> q_cur = new LinkedList<TreeNode>();
        LinkedList<TreeNode> q_next = new LinkedList<TreeNode>();
        q_next.offer(root);  // 先根结点存入q_next
		// 如果下一层结点全部遍历完(没有子树)，循环结束
        while (!q_next.isEmpty()) {
            // System.out.println(res.toString());
			// 将q_next结点全部存入q_cur
            while (!q_next.isEmpty()) {
                TreeNode node = q_next.remove();
                q_cur.add(node);
            }
			// level用于存储当前层的结点元素，每次大循环就new一个level
            ArrayList<Integer> level = new ArrayList<Integer>();
			// 将当前层q_cur的结点全部出队，出队结点元素存入level
			// 将出队结点的左右子结点全部存入q_next(下一层)
			// 如果当前层的结点全部出队，循环结束
            while (!q_cur.isEmpty()) {
                TreeNode node = q_cur.remove();
				level.add(node.val);
                if (node.left != null)
                    q_next.add(node.left);
                if (node.right != null)
                    q_next.add(node.right);
            }
			// 将存好当前层元素的列表level存入res
            res.add(level);
        }
        return res;
    }
}

// 牛客
// 运行时间：24ms
// 占用内存：10000k
import java.util.ArrayList;
import java.util.LinkedList;
public class Solution {
	ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
		ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>;
		LinkedList<TreeNode> q_cur = new LinkedList<>();
		LinkedList<TreeNode> q_next = new LinkedList<>();
		q_next.offer(pRoot);
		while (!q_next.isEmpty()) {
			while (!q_next.isEmpty()) {
				TreeNode node = q_next.remove();
				q_cur.add(node);
			}
			ArrayList<Integer> level = new ArrayList<>();
			while (!q_cur.isEmpty()) {
				TreeNode node = q_cur.remove();
				level.add(node.val);
				if (node.left != null) 
					q_next.add(node.left);
				if (node.right != null)
					q_next.add(node.right);
			}
			res.add(level);
		}
		return res;
	}
}

//////////////////////////////// 计数分割 ////////////////////////
// 比较巧妙的方法
// 设置一个计数位level_count，在根结点出队，放子结点入队后，队伍里的
// 长度即为子结点一层的结点个数。
// 遍历一个结点，计数位减1，计数位耗尽表示当前层遍历完毕。

// 力扣
// 执行用时：1 ms, 在所有 Java 提交中击败了92.86%的用户
// 内存消耗：38.5 MB, 在所有 Java 提交中击败了85.92%的用户
import java.util.ArrayList;
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
		if (root == null)
			return res;
		int level_count = 0;
		LinkedList<TreeNode> q = new LinkedList<>();
		q.offer(root);
		while (!q.isEmpty()) {
			ArrayList<Integer> level = new ArrayList<>();
            level_count = q.size();
			while (level_count > 0) {
				TreeNode node = q.remove();
				level.add(node.val);
				if (node.left != null)
					q.add(node.left);
				if (node.right != null)
					q.add(node.right);
				level_count--;
			}
			res.add(level);
            // System.out.println(res.toString());
		}
		return res;
    }
}

// 牛客
// 运行时间：17ms
// 占用内存：9956k
import java.util.ArrayList;
import java.util.LinkedList;
public class Solution {
	ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
		ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
		if (pRoot == null)
			return res;
		int level_count = 1;
		LinkedList<TreeNode> q = new LinkedList<>();
		q.offer(pRoot);
		while (!q.isEmpty()) {
			ArrayList<Integer> level = new ArrayList<>();
			level_count = q.size();
			while (level_count > 0) {
				TreeNode node = q.remove();
				level.add(node.val);
				if (node.left != null)
					q.add(node.left);
				if (node.right != null)
					q.add(node.right);
				level_count--;
			}
			res.add(level);
		}
		return res;
	}
}