(java)二叉树的前中后序遍历

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;


public class 二叉树的前中后遍历 {
    //建立二叉树结构
    private static class Node {  
        Node leftChild;  
        Node rightChild;  
        int data;
        Node(int data) {  
            leftChild = null;  
            rightChild = null;  
            this.data = data;  
        }  
    }
    /**
     * 创建完全二叉树方法
     * @param bNode 节点对象
     * @param x    数的深度
     */
    public static void createBinTree(Node node,int x,int k) {  
          if(x==1)
              return;
          node.leftChild=new Node(k*2);
          node.rightChild=new Node(k*2+1);
          createBinTree(node.leftChild,x-1,k*2);
          createBinTree(node.rightChild,x-1,k*2+1);
    }  
    /** 
     * 先序遍历 
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     */  
    public static void preOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        System.out.print(node.data + " ");  
        preOrderTraverse(node.leftChild);  
        preOrderTraverse(node.rightChild);  
    }  
  
    /** 
     * 中序遍历 
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     */  
    public static void inOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        inOrderTraverse(node.leftChild);  
        System.out.print(node.data + " ");  
        inOrderTraverse(node.rightChild);  
    }  
  
    /** 
     * 后序遍历 
     *  
     * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已 
     *  
     * @param node 
     *            遍历的节点 
     */  
    public static void postOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        postOrderTraverse(node.leftChild);  
        postOrderTraverse(node.rightChild);  
        System.out.print(node.data + " ");  
    }  
    /**
     * 广度优先算法
     * @param args
     */
    public static void length(Node root) {
        if(root==null)
            return;
        //队列存储节点，每次进来节点，先扫描其子节点进队列，再本身出队列
        Queue<Node> queue=new LinkedList<Node>();
        //进队列，offer在队满时不会报满溢出，只会返回false;
        queue.offer(root);
        while(!queue.isEmpty()){
            //poll移除并返回首部
            Node tree=queue.poll();
            if(tree.leftChild!=null)
                queue.offer(tree.leftChild);
            if(tree.rightChild!=null)
                queue.offer(tree.rightChild);
            System.out.print(tree.data+" ");
        }
        return ;
    }
    /**
     * 深度优先算法，非递归
     * @param args
     */
    public static void deep(Node root) {
        Stack<Node> stack=new Stack<Node>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node tree=stack.pop();
            //先往栈中压入右节点，再压左节点，这样出栈就是先左节点后右节点了。
            if(tree.rightChild!=null)
                stack.push(tree.rightChild);
            if(tree.leftChild!=null)
                stack.push(tree.leftChild);
            System.out.print(tree.data+" ");
        }
        return ;
    }
    public static void main(String[] args) {  
        //建立头节点 
        Node node=new Node(-1);
        createBinTree(node,3,1);  
   
        System.out.println("先序遍历：");  
        preOrderTraverse(node);  
        System.out.println();  
  
        System.out.println("中序遍历：");  
        inOrderTraverse(node);  
        System.out.println();  
  
        System.out.println("后序遍历：");  
        postOrderTraverse(node); 
        System.out.println();
        
        System.out.println("广度优先遍历：");  
        length(node); 
        System.out.println();
        
        System.out.println("深度优先遍历非递归：");  
        deep(node); 
        System.out.println();
    }  
  
}