剑指Offer | 32 - 3 之字形打印二叉树

剑指Offer 32 - 3 之字形打印二叉树

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

 
例如：下面一棵二叉树：

 
按照之字形打印的结果：

 

 

分析：

规律：按之字形顺序打印二叉树需要两个栈。我们在打印某一层的节点时，把下一层的子节点保存到相应的栈里。

如果当前打印的是奇数层（第一层、第三层等），则先保存左子节点再保存右子节点到第一个栈里；

如果当前打印的是偶数层（第二层、第四层等），则先保存右子节点再保存左子节点到第二个栈里。

 
由此代码为：
 

import java.util.Stack;

/*按之字形打印二叉树*/
public class Solution_32_03 {
    //之字形打印二叉树的函数
    public static void Print(TreeNode pRoot) {
        if (pRoot == null) {//当节点为空时
            return ;
        }
        
        //存奇数层的节点
        Stack<TreeNode> stack1 = new Stack<TreeNode>();
        
        //存偶数层的节点
        Stack<TreeNode> stack2 = new Stack<TreeNode>();

        //层数
        int layer = 1;
        
        //将根结点先 push 进 stack1 中
        stack1.push(pRoot);

        // stack1 或 stack2 有一个不为空时，执行下面的代码
        while (!stack1.isEmpty() || !stack2.isEmpty()) {
            
            if (layer % 2 != 0) {//当前层数为奇数层
               
                while (!stack1.isEmpty()) {//消耗 stack1 中的节点
                 
                    TreeNode node = stack1.pop();
                    System.out.print(node.val+" , ");
                    
                    //如果当前层为奇数层，则它子节点进栈的顺序是：左孩子先进，右孩子再进
                    if (node.left != null) {
                        stack2.push(node.left);
                    }
                  
                    if (node.right != null) {
                        stack2.push(node.right);
                    }
                }
             
                //当前层的节点消耗完成，层数加 1
                layer++;
                //换行
                System.out.println();

            }else {//当前层数为偶数层
             
                while (!stack2.isEmpty()) {//消耗 stack2 中的节点
                    
                    TreeNode node = stack2.pop();
                    System.out.print(node.val+" , ");

                    //如果当前层为偶数层，则它子节点进栈的顺序是：右孩子先进，左孩子再进
                    if (node.right != null) {
                        stack1.push(node.right);
                    }
                    
                    if (node.left != null) {
                        stack1.push(node.left);
                    }
                }
              
                //当前层的节点消耗完成，层数加 1
                layer++;
                 //换行
                System.out.println();
            }
        }
    }



    //二叉树的节点
    public static class TreeNode {
        int val = 0;
        TreeNode left = null;
        TreeNode right = null;

        public TreeNode(int val) {
            this.val = val;

        }

    }


    //测试主函数
    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(3);
        root1.left.left = new TreeNode(4);
        root1.left.right = new TreeNode(5);
        root1.right.left = new TreeNode(6);
        root1.right.right = new TreeNode(7);
        root1.left.left.left = new TreeNode(8);
        root1.left.left.right = new TreeNode(9);
        root1.left.right.left = new TreeNode(10);
        root1.left.right.right = new TreeNode(11);
        root1.right.left.left = new TreeNode(12);
        root1.right.left.right = new TreeNode(13);
        root1.right.right.left = new TreeNode(14);
        root1.right.right.right = new TreeNode(15);
        
        Solution_32_03.Print(root1);

    }
}

 
输出结果：