二叉树的先序、中序、后序和中序遍历——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-->