交差方向遍历bfs 树

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
enum Dirction {left , right}
    public class Tree {
        private BinaryTreeNode root;
        private List<Object> list = new ArrayList();
        Dirction current  = Dirction.right;
        
        public Dirction get_dirction(){
            current = current == Dirction.left ? Dirction.right : Dirction.left;
            return current;
        }
        
        public void printchild(Queue<BinaryTreeNode> child, Dirction dir){
            Queue<BinaryTreeNode> buf = new LinkedList<BinaryTreeNode>(child);
            
            if(dir == Dirction.left){
                while(!buf.isEmpty()){
                    BinaryTreeNode o = buf.poll();
                    if(o!=null)
                      System.out.print(o.info);
                }
            }else{
            Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
            while(!buf.isEmpty()){
                stack.add(buf.poll());
            }
            while(!stack.isEmpty()){
                BinaryTreeNode o = stack.pop();
                if(o!=null)
                System.out.print(o.info);
            }
            
            return;
            }
            
            
        }


        // 树的层次遍历
        public void bfs() {
            Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
            Queue<BinaryTreeNode> childQueue = new LinkedList<BinaryTreeNode>();
            BinaryTreeNode current;
            current = root;
            System.out.print(root.info);

            while(true){
            while ((current != null) || (!queue.isEmpty())) {
                if (current != null) {
                    //System.out.print(current.info);
                    list.add(current);
                    childQueue.add(current.llink);
                    childQueue.add(current.rlink);
                    current = queue.poll();
                } else {
                    current = queue.poll();
                }
            }
            
            if(childQueue.size() == 0)
                break;
            
//            list.add(get_dirction());
            printchild(childQueue,get_dirction());
            Queue<BinaryTreeNode> buffer = queue;
            queue = childQueue;
            childQueue = buffer;
            childQueue.clear();
    
            }
            
//            for(Object o : list){
//                System.out.print(o.toString()+ " ");
//            }
        }
        

        public class BinaryTreeNode {
            private BinaryTreeNode llink = null;
            private BinaryTreeNode rlink = null;
            private int info;
            private boolean isFirst;

            public BinaryTreeNode(int info) {
                this.info = info;
            }
            
            @Override
            public String toString(){
                return Integer.toString(info);
            }
        }

        public void initTree() {
            root = new BinaryTreeNode(1);
            root.llink = new BinaryTreeNode(2);
            root.rlink = new BinaryTreeNode(3);
            root.llink.llink = new BinaryTreeNode(4);
            root.llink.rlink = new BinaryTreeNode(5);
            root.rlink.llink = new BinaryTreeNode(6);
            root.rlink.rlink = new BinaryTreeNode(7);
        }
        
//          1
//        2    3
//      4  5    6  7
         

        public BinaryTreeNode getRoot() {
            return root;
        }

        public void setRoot(BinaryTreeNode root) {
            this.root = root;
        }
        
        

        public static void main(String[] args) {
            Tree tree = new Tree();
            tree.initTree();
            tree.bfs();
            System.out.println("");
            
//            Queue<Integer> test1 = new LinkedList<Integer>();
//            Queue<Integer> test2 = new LinkedList<Integer>();
//            
//            test1.add(1);
//            test2.add(2);
//            
//            Queue<Integer> buf = test1;
//            test1 = test2;
//            test2 = buf;
//            test2.c
//            System.out.println(test1.peek()  +  "  " + test2.peek());

        }
    }

输出  

1237654.