二叉树层次遍历，打印每一层固定位置元素。

前几天面试，遇到一道算法题：二叉树层次遍历，打印每一层固定位置元素，若该层元素数量不够，则打印null。
好长时间没写算法了，树的层次遍历都已经忘的干干净净。面试的时候按照自己的想法写，过程中面试官一直提示用别的方法，最后没做出来。下来仔细想了想，自己的做法也是可以的，现在把两种算法都写出来，供大家参考。

public class Tree {

	//	二叉树结构定义
    static class TreeNode {
        int data;
        TreeNode left;
        TreeNode right;
        int layer;
        int pos;

        public TreeNode(int data) {
            this.data = data;
        }
    }

    //	算法一：层次遍历打印，按照层次每行输出二叉树所有元素
    public void printTree(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        // 当前层最右节点
        TreeNode last = root;
        // 下一层最右节点
        TreeNode nextlast = null;
        while (!queue.isEmpty()) {
            TreeNode t = queue.poll();
            System.out.print(t.data + " ");
            if (t.left != null) {
                queue.add(t.left);
                nextlast = t.left;
            }
            if (t.right != null) {
                queue.add(t.right);
                nextlast = t.right;
            }
            // 如果当前输出结点是最右结点，那么换行
            if (last == t) {
                System.out.println();
                last = nextlast;
            }
        }
    }

    //	算法二：面试自己写到一半的算法，逻辑不清晰，且需要给元素TreeNode增开属性
    public void printTree2(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        // 层次标记
        int layer = 0;
        // 每层相对位置
        int pos = 0;
        while (!queue.isEmpty()) {
            TreeNode t = queue.poll();
            if(layer <= t.layer) {
                // 新的一层开始
                layer++;
                pos = 0;
                if(t != root) {
                    // 打印换行
                    System.out.println();
                }
            }
            System.out.print(t.data + " ");
            if (t.left != null) {
                t.left.layer = layer;
                t.left.pos = pos++;
                queue.add(t.left);
            }
            if (t.right != null) {
                t.right.layer = layer;
                t.right.pos = pos++;
                queue.add(t.right);
            }
        }
        System.out.println();
    }

    //	算法三：思想同算法二
    public void printTree3(TreeNode root) {
        int N = 3;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        // 层次标记
        int layer = 0;
        // 每层相对位置
        int pos = 0;
        while (!queue.isEmpty()) {
            TreeNode t = queue.poll();
            if(t.pos == N - 1) {
                System.out.println(t.data + " ");
            }
            if(layer <= t.layer) {
                // 新的一层开始
                layer++;
                if(pos < N) {
                    System.out.println("null");
                }
                pos = 0;
            }
            if (t.left != null) {
                t.left.layer = layer;
                t.left.pos = pos++;
                queue.add(t.left);
            }
            if (t.right != null) {
                t.right.layer = layer;
                t.right.pos = pos++;
                queue.add(t.right);
            }
        }
        System.out.println();
    }

    //	算法四：二叉树层序遍历，采用队列实现，代码省略


	// 主函数
    public static void main(String[] args) {
        // 构建二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.right.left = new TreeNode(5);
        root.right.right = new TreeNode(6);
        root.right.left.left = new TreeNode(7);
        root.right.left.right = new TreeNode(8);
        Tree test = new Tree();
        test.printTree(root);
        test.printTree2(root);
        test.printTree3(root);
    }
}