按之形顺序打印二叉树

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree{3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

 

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

confused what"{1,#,2,3}"means? > read more on how binary tree is serialized on OJ.

 

package niuke.day1;

import java.util.ArrayList;

public class Binary_tree_zigzag_level_order_traversal {
        public static void main(String[] args) {
            TreeNode t1 = new TreeNode(1);
            TreeNode t2 = new TreeNode(2);
            TreeNode t3 = new TreeNode(3);
            TreeNode t4 = new TreeNode(4);
            TreeNode t5 = new TreeNode(5);
            TreeNode t6 = new TreeNode(6);
            TreeNode t7 = new TreeNode(7);
            t1.left = t2;
            t1.right = t3;
            t2.left = t4;
            t2.right = t5;
            t3.left = t6;
            t3.right = t7;
            System.out.println(zigzagLevelOrder(t1));
        }
        
        public static ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
            ArrayList<ArrayList<Integer>> AL = new ArrayList<>();
            zigzagLevelOrder(root,AL,0);
            return AL;
        }
         //需要注意两点，一个是递归的学习调用，另一个是arraylist的一些函数方法
        private static void zigzagLevelOrder(TreeNode node, ArrayList<ArrayList<Integer>> AL, int level ) {
            // TODO Auto-generated method stub
            if(node == null)                   //当节点为空节点，就返回
                return;
            if(level == AL.size()) {
                ArrayList<Integer> new1 = new ArrayList<>();   //建立新的数组，用于存放节点对应的数值
                if(level % 2 == 0) {
                    new1.add(node.val);       //根节点当做0层的话，就是偶数层是从左到右，顺序是正常顺序
                }else {
                    new1.add(0 , node.val);  //当层数为奇数的时候，就反着添加
                }
                AL.add(new1);                 //然后把对应保存的数组添加到AL中，只是暂时占住一个位置，运用递归，当之后遇到同层的之后，在else中此位置会被重新更新
            }else {
                ArrayList<Integer> new2 = AL.get(level);      //当level对应在AL中的位置已经被占据，则以原来位置的数组去初始化新数组
                if(level % 2 == 0) {
                    new2.add(node.val);                       //然后对应在新数组中添加元素
                }else {
                    new2.add(0 , node.val);
                }
                AL.set(level, new2);                          //再利set函数，把原来原味的数组进行替换
            }
            zigzagLevelOrder(node.left,AL,level + 1);           //递归调用，依次把对应节点的左右子节点进行递归添加，直到遇到空节点为止
            zigzagLevelOrder(node.right,AL,level + 1);    
        }
        
}

此页源代码借鉴：https://www.nowcoder.com/profile/9122222/codeBookDetail?submissionId=29626757