二叉树的创建以及遍历

package test.Tree;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
  int val = 0;
  TreeNode left = null;
  TreeNode right = null;
  public TreeNode(int val){
      this.val=val;
  }
  public  TreeNode(int val,TreeNode left,TreeNode right){
      this.val=val;
      this.left=left;
      this.right=right;
  }
}


public class Solution {
public   TreeNode  createTreeNode(){
    TreeNode t8=new TreeNode(8,null,null);
    TreeNode t7=new TreeNode(7,null,null);
    TreeNode t6=new TreeNode(6,t8,null);
    TreeNode t5=new TreeNode(5,null,null);
    TreeNode t4=new TreeNode(4,null,t7);
    TreeNode t3=new TreeNode(3,t5,t6);
    TreeNode t2=new TreeNode(2,t4,null);
    TreeNode t1=new TreeNode(1,t2,t3);
    return t1;
}
    /**
     * 先序遍历
     *
     * @param root
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     *
     */
    public void preOrder(TreeNode root){
        if(root == null)
            return;
        System.out.print(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }
    /**
     * 中序遍历
     *
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     *
     * @param root
     *            遍历的节点
     */
    public void inOrder(TreeNode root){
        if(root == null)
            return;
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }
    /**
     * 后序遍历
     *
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     *
     * @param root
     *            遍历的节点
     */
    public void postOrder(TreeNode root){
        if(root == null)
            return;

        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val+" ");
    }

    /**
     * 层序遍历
     *
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
     *
     * @param root
     *            遍历的节点
     */
    public static int[] levelOrder(TreeNode root){
        // 用于记录元素顺序
        ArrayList<Integer> list = new ArrayList<>();
        // 构建队列,辅助完成层次遍历
        LinkedList<TreeNode> queue = new LinkedList<>();
        if(root==null)
            return new int[0];
        // 将树的根节点入队
        queue.add(root);
        // 队列不为空时循环
        while (queue.size()!=0){
            //出队
            TreeNode node = queue.poll();
            list.add(node.val);
            if(node.left!=null)
                queue.add(node.left);
            if (node.right!=null)
                queue.add(node.right);

        }
        int res[]=new int[list.size()];
        for (int i = 0; i <res.length ; i++) {
            res[i]=list.get(i);
        }
        return res;
    }
    //右序遍历
    private int[] cenxu(TreeNode root){
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        List<Integer> res = new ArrayList<>();
        while(queue.size()!=0){
            int len = queue.size();

            for(int i=1;i<=len;i++){
                TreeNode tn = queue.removeFirst();
                if(tn.left!=null) queue.add(tn.left);
                if(tn.right!=null) queue.add(tn.right);
                //最后一个
                if(i==len)
                    res.add(tn.val);
            }
        }
        int[] r = new int[res.size()];
        int y = 0;
        for(int a:res){
            r[y++] = a;
        }
        return r;
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        TreeNode treeNode = s.createTreeNode();
        System.out.println("\n"+"先序遍历：");
        s.preOrder(treeNode);
        System.out.println("\n"+"中序遍历：");
        s.inOrder(treeNode);
        System.out.println("\n"+"后序遍历：");
        s.postOrder(treeNode);
        System.out.println("\n"+"层序遍历：");
        int[] ints = s.levelOrder(treeNode);
        for (int i = 0; i <ints.length ; i++) {
            System.out.print(ints[i]+" ");
        }
        System.out.println();
        int[] bfs = s.cenxu(treeNode);
        for (int i = 0; i <bfs.length ; i++) {
            System.out.print(+bfs[i]+" ");
        }
    }
}

输出样例