16.输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印

转载请注明出处：http://www.cnblogs.com/wuzetiandaren/p/4261605.html

声明：现大部分文章为寻找问题时在网上相互转载，此博是为自己做个记录记录，方便自己也方便有类似问题的朋友，本文的思想也许有所借鉴，但源码均为本人实现，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。

题目：输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。

题目分析：可以用一个LinkedList的数据结构模拟队列来完成此操作。传入树的根节点root。

　　1.如果root为空则结束交换，否则root 入队。

　　2.当队列不为空时进行如下操作：

　　　　a.队首元素出队，交换队首元素节点的左右孩子。

　　　　b.如果队首元素的左孩子不为空，左孩子节点入队；如果队首元素的右孩子不为空，右孩子节点进栈。

算法实现：

    //层序遍历,使用LinkedList数据结构来模拟队列
    private void levelOrder(Node root){
        if(root==null){
            System.out.println("
二叉树为空！");
            return;
        }
        System.out.println("
这是二叉排序树的层序遍历结果:");
        LinkedList<Node> queue = new LinkedList<Node>();
        queue.add(root);      //根节点先入队
        while(queue.size()!=0){
            Node node = queue.removeFirst();  //得到并删除队列的第一个节点
            System.out.print(node.data+" ");
            if(node.left!=null){   //该节点的左孩子入队
                queue.add(node.left);
            }
            if(node.right!=null){   //该节点的右孩子入队
                queue.add(node.right);
            }
        }
        System.out.println();
    }

java实现完整源码：

package com.interview;

import java.util.LinkedList;

/**
 * 题目:输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。
 * @author wjh
 *
 */
public class _16LeverOrder {

    /**
     * @param args
     */
    public static void main(String[] args) {
        _16LeverOrder builder= new _16LeverOrder();
        int[] a = {20,5,22,4,7,25,13,36,42,11,24};
        Node root = null;
        root = builder.buildTree(root, a); //1)创建二叉排序树
        builder.levelOrder(root);
    }

    //层序遍历,使用LinkedList数据结构来模拟队列
    private void levelOrder(Node root){
        if(root==null){
            System.out.println("
二叉树为空！");
            return;
        }
        System.out.println("
这是二叉排序树的层序遍历结果:");
        LinkedList<Node> queue = new LinkedList<Node>();
        queue.add(root);      //根节点先入队
        while(queue.size()!=0){
            Node node = queue.removeFirst();  //得到并删除队列的第一个节点
            System.out.print(node.data+" ");
            if(node.left!=null){   //该节点的左孩子入队
                queue.add(node.left);
            }
            if(node.right!=null){   //该节点的右孩子入队
                queue.add(node.right);
            }
        }
        System.out.println();
    }
    
    
    //建二叉排序树
    private Node buildTree(Node root, int[] data) {
        int n = data.length;
        System.out.println("建树过程(a<--b表示在a左边插入b;a-->b表示在a右边插入b):");
        for (int i = 0; i < n; i++) {
        root=insert(root, data[i]);
        }
        return root;
     }
                
    //一次插入节点
    private Node insert(Node node, int data) {
        if (node == null) {
            node = new Node(data,null,null);
            System.out.println(node.data);
         }else{ 
            if(data <= node.data) {
                System.out.print(node.data+"<--");//在root左边插入
                node.left = insert(node.left, data);
             } else {
                System.out.print(node.data+"-->"); //在root右边插入
                node.right = insert(node.right, data);
             }
         }
         return node;
    }
    
    //创建一个树节点类
    class Node {
        public int data;
        public Node left;  //指向左孩子的指针    
        public Node right;  //指向右孩子的指针    
        public Node() {
            super();
        }
        public Node(int data, Node left, Node right) {
            super();
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
}

运行结果：

建树过程(a<--b表示在a左边插入b;a-->b表示在a右边插入b):
20
20<--5
20-->22
20<--5<--4
20<--5-->7
20-->22-->25
20<--5-->7-->13
20-->22-->25-->36
20-->22-->25-->36-->42
20<--5-->7-->13<--11
20-->22-->25<--24

这是二叉排序树的层序遍历结果:
20 5 22 4 7 25 13 24 36 11 42