java 实现二叉树的遍历

1、定义一个节点类：

public class Node {  
    private int data;  
    private Node left;  
    private Node right;  

    public Node(){}

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

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

    public int getData() {  
        return data;  
    }  
    public void setData(int data) {  
        this.data = data;  
    }  
    public Node getLeft() {  
        return left;  
    }  
    public void setLeft(Node left) {  
        this.left = left;  
    }  
    public Node getRight() {  
        return right;  
    }  
    public void setRight(Node right) {  
        this.right = right;  
    }  

}  

2、算法实现类：

public class BinaryNode{
  //前序遍历递归的方式
    public void preOrder(Node root){
        if(null!=root){
            System.out.print(root.getData()+"\t");
            preOrder(root.getLeft());
            preOrder(root.getRight());
        }
    }

    //前序遍历非递归的方式
    public void preOrderNonRecursive(Node  root){
        Stack<Node> stack=new Stack<Node>();
        while(true){
            while(root!=null){
                System.out.print(root.getData()+"\t");
                stack.push(root);
                root=root.getLeft();
            }
            if(stack.isEmpty()) break;
            root=stack.pop();
            root=root.getRight();
        }
    }

    //中序遍历采用递归的方式
    public void inOrder(Node root){
        if(null!=root){
            inOrder(root.getLeft());
            System.out.print(root.getData()+"\t");
            inOrder(root.getRight());
        }
    }

    //中序遍历采用非递归的方式
    public void inOrderNonRecursive(Node root){
        Stack<Node> stack=new Stack<Node>();
        while(true){
            while(root!=null){
                stack.push(root);
                root=root.getLeft();
            }
            if(stack.isEmpty())break;
            root=stack.pop();
            System.out.print(root.getData()+"\t");
            root=root.getRight();
        }
    }

    //后序遍历采用递归的方式
    public void postOrder(Node  root){
        if(root!=null){
            postOrder(root.getLeft());
            postOrder(root.getRight());
            System.out.print(root.getData()+"\t");
        }
    }

    //后序遍历采用非递归的方式
    public void postOrderNonRecursive(Node root){
        Stack<Node> stack=new Stack<Node>();
        while(true){
            if(root!=null){
                stack.push(root);
                root=root.getLeft();
            }else{
                if(stack.isEmpty()) return;

                if(null==stack.lastElement().getRight()){
                    root=stack.pop();
                    System.out.print(root.getData()+"\t");
                    while(root==stack.lastElement().getRight()){
                        System.out.print(stack.lastElement().getData()+"\t");
                        root=stack.pop();
                        if(stack.isEmpty()){
                            break;
                        }
                    }
                }

                if(!stack.isEmpty())
                    root=stack.lastElement().getRight();
                else
                    root=null;
            }
        }
    }
//层序遍历
    public void levelOrder(Node root){
        Node temp;
        Queue<Node> queue=new LinkedList<Node>();
        queue.offer(root);
        while(!queue.isEmpty()){
            temp=queue.poll();
            System.out.print(temp.getData()+"\t");
            if(null!=temp.getLeft())
                queue.offer(temp.getLeft());
            if(null!=temp.getRight()){
                queue.offer(temp.getRight());
            }
        }
    }
  }

3、遍历测试下图二叉树

public static void main(String[] args) {
        Node node10=new Node(10,null,null);
        Node node8=new Node(8,null,null);
        Node node9=new Node(9,null,node10);
        Node node4=new Node(4,null,null);
        Node node5=new Node(5,node8,node9);
        Node node6=new Node(6,null,null);
        Node node7=new Node(7,null,null);
        Node node2=new Node(2,node4,node5);
        Node node3=new Node(3,node6,node7);
        Node node1=new Node(1,node2,node3);

        BinaryNode tree=new BinaryNode();
        //采用递归的方式进行遍历
        System.out.println("-----前序遍历------");
        tree.preOrder(node1);        // 1   2   4   5   8   9   10  3   6   7   
        System.out.println();
        //采用非递归的方式遍历
        tree.preOrderNonRecursive(node1);        // 1   2   4   5   8   9   10  3   6   7   
        System.out.println();


        //采用递归的方式进行遍历
        System.out.println("-----中序遍历------");
        tree.inOrder(node1);    //   4  2   8   5   9   10  1   6   3   7
        System.out.println();
        //采用非递归的方式遍历
        tree.inOrderNonRecursive(node1);    //   4  2   8   5   9   10  1   6   3   7
        System.out.println();

        //采用递归的方式进行遍历
        System.out.println("-----后序遍历------");
        tree.postOrder(node1);    //   4    8   10  9   5   2   6   7   3   1   
        System.out.println();
        //采用非递归的方式遍历
        tree.postOrderNonRecursive(node1);    //   4    8   10  9   5   2   6   7   3   1   
        System.out.println();

        //采用递归的方式进行遍历
        System.out.println("-----层序遍历------");
        tree.levelOrder(node1);    //  1    2   3   4   5   6   7   8   9   10  
        System.out.println();
    }