二叉树的先序、中序、后序和中序遍历——Java实现

 package treeTraverse;
 /**
  * 定义一个树的结点类
  */
 public class Node {
     private int data;
     private Node leftChild;
     private Node rightChild;

     public Node(){

     }

     public Node(int data) {
         super();
         this.data = data;
     }

     public int getData() {
         return data;
     }

     public void setData(int data) {
         this.data = data;
     }

     public Node getLeftChild() {
         return leftChild;
     }

     public void setLeftChild(Node leftChild) {
         this.leftChild = leftChild;
     }

     public Node getRightChild() {
         return rightChild;
     }

     public void setRightChild(Node rightChild) {
         this.rightChild = rightChild;
     }

 }

 package treeTraverse;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * 实现树的先、中、后及层次遍历
  */
 public class FindTree {

     private void visit(int data){
         System.out.print(data + "-->");
     }
     //先序遍历
     public void preOrder(Node root){
         if(root == null) return ;

         visit(root.getData());
         preOrder(root.getLeftChild());
         preOrder(root.getRightChild());
     }
     //中序遍历
     public void inOrder(Node root){
         if(root == null) return ;

         inOrder(root.getLeftChild());
         visit(root.getData());
         inOrder(root.getRightChild());
     }
     //后序遍历
     public void afterOrder(Node root){
         if(root == null) return ;

         afterOrder(root.getLeftChild());
         afterOrder(root.getRightChild());
         visit(root.getData());
     }

     /**
      * 层次遍历(非递归)
      * 思路：
      * 现将二叉树头结点入队列，然后出队列，访问该结点，
      * 如果它有左子树，则将左子树根节点入队;
      * 如果它有右子树，则将右子树根节点入队;
      * 然后出队列，对出队列的结点访问，如此反复，知道队列为空。
      */
     public void levelOrder(Node root){

         List<Node> queue = new ArrayList<Node>();
         if(root != null){
             queue.add(root);//将根结点入队
             while(queue.size() != 0){//当队列不空的时候进行循环
                 Node q = queue.remove(0);//出队列       返回从列表中移除的元素
                 visit(q.getData());//访问该结点

                 if(q.getLeftChild() != null){//如果它有左子树，则将左子树根节点入队;
                     queue.add(q.getLeftChild());
                 }
                 if(q.getRightChild() != null){//如果它有右子树，则将右子树根节点入队;
                     queue.add(q.getRightChild());
                 }
             }
         }
     }
 }

 package treeTraverse;

 /**
  * 构建一个二叉树排序树并测试
  */
 public class TestTree {
     public static void main(String[] args) {
         FindTree ft = new FindTree();
         int[] array = {12,76,35,22,16,48,90,46,9,40,90};

         Node root = new Node(array[0]);
         for(int i = 1; i < array.length; i++){
             insert(root, array[i]);
         }
         System.out.println("preorder:");
         ft.preOrder(root);
         System.out.println("\n"+"inorder:");
         ft.inOrder(root);
         System.out.println("\n"+"afterorder:");
         ft.afterOrder(root);
         System.out.println("\n"+"levelOrder:");
         ft.levelOrder(root);
     }

     /**
      * 构造二叉排序树, 性质如下:
      * 若它的左子树不空,则左子树上所有关键字的值均小于根关键字的值
      * 若它的右子树不空,则右子树上所有关键字的值均小于根关键字的值
      * 如果输出二叉树排序树的中序遍历，则这个序列是递增有序的
      * @param root
      * @param data
      */
     private static void insert(Node root, int data) {
         if(root.getData() < data){
             if(root.getRightChild() == null){
                 root.setRightChild(new Node(data));
             }else{
                 insert(root.getRightChild(), data);
             }
         }else {
             if(root.getData() > data){
                 if(root.getLeftChild() == null){
                     root.setLeftChild(new Node(data));
                 }else{
                     insert(root.getLeftChild(), data);
                 }
             }
         }
     }

 }

遍历结果：

preorder:
12-->9-->76-->35-->22-->16-->48-->46-->40-->90-->
inorder:
9-->12-->16-->22-->35-->40-->46-->48-->76-->90-->
afterorder:
9-->16-->22-->40-->46-->48-->35-->90-->76-->12-->
levelOrder:
12-->9-->76-->35-->90-->22-->48-->16-->46-->40-->