剑指Offer（五十九）：按之字顺序打印二叉树(Java版)

描述

给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）

数据范围：0 \le n \le 15000≤n≤1500,树上每个节点的val满足 |val| <= 100∣val∣<=100

要求：空间复杂度：O(n)O(n)，时间复杂度：O(n)O(n)

例如：

给定的二叉树是{1,2,3,#,#,4,5}

该二叉树之字形层序遍历的结果是

[

[1],

[3,2],

[4,5]

]

示例1

输入：{1,2,3,#,#,4,5}

返回值：[[1],[3,2],[4,5]]

说明：如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。

示例2

输入：{8,6,10,5,7,9,11}

返回值：[[8],[10,6],[5,7,9,11]]

示例3

输入：{1,2,3,4,5}

返回值：[[1],[3,2],[4,5]]

第一种解法

使用一个队列来做完辅助工具，由于队列的特性的先进先出，第一次就把根节点放进去，然后循环遍历节点，利用一个变量来控制是从左往右遍历，还是从右往左遍历，依次放入队列中，最后依次从队列中取出节点，放入list中即可，代码如下

public ArrayList<ArrayList<Integer>> firstPrint(TreeNode<Integer> pRoot) {
        ArrayList<ArrayList<Integer>> list  = new  ArrayList<ArrayList<Integer>>();
       if(null == pRoot){
           return list;
       }
        Queue<TreeNode> queue = new LinkedList<>();
       queue.add(pRoot);
       //true代表从左往右 否则从右往左
       boolean flag = false;
       while (!queue.isEmpty()){
           int size = queue.size();
           ArrayList<Integer> arrayList = new ArrayList<>();
           for (int i = 0; i < size; i++) {
               TreeNode<Integer> poll = queue.poll();
               if(poll == null){
                   continue;
               }
               if(flag){
                   arrayList.add(0,poll.val);
               }else {
                   arrayList.add(poll.val);
               }
               queue.add(poll.left);
               queue.add(poll.right);
           }
           if(arrayList.size() > 0){
               list.add(arrayList);
           }
           flag = !flag;
       }
       return list;
    }

 

第二种解法

借助两个栈来解决，由于栈是先进后出，我们将从左往右遍历的节点放入第一个栈中，从右往左遍历的节点从第一个栈中转移到第二个栈中即可，代码如下

 public ArrayList<ArrayList<Integer>> secondPrint(TreeNode<Integer> pRoot) {
        ArrayList<ArrayList<Integer>> list  = new  ArrayList<ArrayList<Integer>>();
        if(null == pRoot){
            return list;
        }
        Stack<TreeNode> stackLeft = new Stack<>();
        Stack<TreeNode> stackRight = new Stack<>();
        stackLeft.add(pRoot);
        //true代表从左往右 否则从右往左
        boolean flag = false;
        while (!stackLeft.isEmpty() || !stackRight.isEmpty()){
            int size = stackLeft.size();
            ArrayList<Integer> arrayList = new ArrayList<>();
            if(!stackLeft.isEmpty()){
                for (int i = 0; i < size; i++) {
                    TreeNode<Integer> poll = stackLeft.pop();
                    if(poll == null){
                        continue;
                    }
                    if(flag){
                        arrayList.add(poll.val);
                    }else {
                        arrayList.add(0,poll.val);
                    }
                    stackRight.add(poll.right);
                    stackRight.add(poll.left);
                }
            }else {
                size = stackRight.size();
                for (int i = 0; i < size; i++) {
                    TreeNode<Integer> poll = stackRight.pop();
                    if(poll == null){
                        continue;
                    }
                    if(flag){
                        arrayList.add(0,poll.val);
                    }else {
                        arrayList.add(poll.val);
                    }
                    stackLeft.add(poll.left);
                    stackLeft.add(poll.right);
                }
            }
            if(arrayList.size() > 0){
                list.add(arrayList);
            }
            flag = !flag;
        }
        return list;
    }