【剑指offer】32.3 从上到下打印二叉树3 / 按之字形顺序打印二叉树

题目描述

// 32.3 从上到下打印二叉树3 / 按之字形顺序打印二叉树

// 力扣
// 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右
// 的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到
// 右的顺序打印，其他行以此类推。


// 牛客
// 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打
// 印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，
// 其他行以此类推。

题解

///////////////////////////// 列表翻转法 /////////////////////////

// 直接在《32.2 从上到下打印二叉树2》基础上改一改就行
// 新增方向判断符，判断这一层的打印方向。需要反方向则直接反转列表。


// 牛客
// 运行时间：16ms
// 占用内存：9904k
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Collections;
public class Solution {
	
	public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
		ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
		if (pRoot == null)
			return res;
		LinkedList<TreeNode> q = new LinkedList<>();
		int level_count = 0;
        boolean left_dic = false;  // 下一层的方向(从左到右还是从右到左)
		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--;
                if (level_count <= 0)
                    left_dic = !left_dic;
            }
            if (!left_dic)
                Collections.reverse(level);
			res.add(level);
		}
		return res;
	}
}


// 力扣
// 执行用时：2 ms, 在所有 Java 提交中击败了27.31%的用户
// 内存消耗：38.4 MB, 在所有 Java 提交中击败了94.68%的用户
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Collections;
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
		if (root == null)
			return res;
		LinkedList<TreeNode> q = new LinkedList<>();
		int level_count = 0;
        boolean left_dic = false;
		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--;
                if (level_count <= 0)
                    left_dic = !left_dic;
            }
            if (!left_dic)
                Collections.reverse(level);
			res.add(level);
		}
		return res;
    }
}

////////////////////////////////// 双端队列法 ///////////////////////////////

// 根据方向判定符left_dic，在双端队列(其他数据结构也行)中使用头部入队或者是尾部入队，
// 其他地方还是一样的套路。

// 力扣
// 执行用时：1 ms, 在所有 Java 提交中击败了99.76%的用户
// 内存消耗：38.9 MB, 在所有 Java 提交中击败了21.29%的用户
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Collections;
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
		if (root == null)
			return res;
		LinkedList<TreeNode> q = new LinkedList<>();
		int level_count = 0;
        boolean left_dic = false;  // 下一层的方向(从左到右还是从右到左)
		q.offer(root);
		while (!q.isEmpty()) {
			LinkedList<Integer> level = new LinkedList<>();
			level_count = q.size();
            while (level_count > 0) {
                TreeNode node = q.remove();
				if (left_dic)
					level.addFirst(node.val);
				else 
					level.addLast(node.val);
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                level_count--;
                if (level_count <= 0)
                    left_dic = !left_dic;
            }
			res.add(level);
		}
		return res;
    }
}


// 牛客
// 跟力扣一样，只是返回的数据类型有区别
// 力扣的方法在牛客不能用，但是牛客的方法在力扣可以用
// 运行时间：16ms
// 占用内存：9996k
import java.util.ArrayList;
import java.util.LinkedList;
public class Solution {
	
	public ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
		if (pRoot == null)
			return res;
		LinkedList<TreeNode> q = new LinkedList<>();
		int level_count = 0;
        boolean left_dic = false;  // 下一层的方向(从左到右还是从右到左)
		q.offer(pRoot);
		while (!q.isEmpty()) {
			ArrayList<Integer> level = new ArrayList<>();
			level_count = q.size();
            while (level_count > 0) {
                TreeNode node = q.remove();
				if (left_dic)
					level.add(0, node.val);  // 如果是ArrayList就这样子操作
				else 
					level.add(node.val);
                if (node.left != null)
                    q.add(node.left);
                if (node.right != null)
                    q.add(node.right);
                level_count--;
                if (level_count <= 0)
                    left_dic = !left_dic;
            }
			res.add(level);
		}
		return res;
	}
}