JAVA实现二叉树的前序、中序、后序遍历

创建一棵树：

public class Node {  
    private int data;  
    private Node leftNode;  
    private Node rightNode;  
    public Node(int data, Node leftNode, Node rightNode){  
        this.data = data;  
        this.leftNode = leftNode;  
        this.rightNode = rightNode;  
    }  
  
    public int getData() {  
        return data;  
    }  
    public void setData(int data) {  
        this.data = data;  
    }  
    public Node getLeftNode() {  
        return leftNode;  
    }  
    public void setLeftNode(Node leftNode) {  
        this.leftNode = leftNode;  
    }  
    public Node getRightNode() {  
        return rightNode;  
    }  
    public void setRightNode(Node rightNode) {  
        this.rightNode = rightNode;  
    }  
}

递归：

public class BinaryTree {  
    /** 
     * @author yaobo
     * 二叉树的先序中序后序排序 
     */  
    public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错  
        Node J = new Node(8, null, null);  
        Node H = new Node(4, null, null);  
        Node G = new Node(2, null, null);  
        Node F = new Node(7, null, J);  
        Node E = new Node(5, H, null);  
        Node D = new Node(1, null, G);  
        Node C = new Node(9, F, null);  
        Node B = new Node(3, D, E);  
        Node A = new Node(6, B, C);  
        return A;   //返回根节点  
    }
    
    public void printNode(Node node){  
        System.out.print(node.getData());  
    }  
    public void theFirstTraversal(Node root) {  //先序遍历  
        printNode(root);  
        if (root.getLeftNode() != null) {  //使用递归进行遍历左孩子  
            theFirstTraversal(root.getLeftNode());  
        }  
        if (root.getRightNode() != null) {  //递归遍历右孩子  
            theFirstTraversal(root.getRightNode());  
        }  
    }  
    public void theInOrderTraversal(Node root) {  //中序遍历  
        if (root.getLeftNode() != null) {  
            theInOrderTraversal(root.getLeftNode());  
        }  
        printNode(root);  
        if (root.getRightNode() != null) {  
            theInOrderTraversal(root.getRightNode());  
        }  
    }
    
    
    public void thePostOrderTraversal(Node root) {  //后序遍历  
        if (root.getLeftNode() != null) {  
            thePostOrderTraversal(root.getLeftNode());  
        }  
        if(root.getRightNode() != null) {  
            thePostOrderTraversal(root.getRightNode());  
        }  
        printNode(root);  
    }  
      
    public static void main(String[] args) {  
        BinaryTree tree = new BinaryTree();  
        Node root = tree.init();  
        System.out.println("先序遍历");  
        tree.theFirstTraversal(root);  
        System.out.println("");  
        System.out.println("中序遍历");  
        tree.theInOrderTraversal(root);  
        System.out.println("");  
        System.out.println("后序遍历");  
        tree.thePostOrderTraversal(root);  
        System.out.println("");  
    }  
}

堆栈：

public class BinaryTree1 { 
     public Node init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错  
            Node J = new Node(8, null, null);  
            Node H = new Node(4, null, null);  
            Node G = new Node(2, null, null);  
            Node F = new Node(7, null, J);  
            Node E = new Node(5, H, null);  
            Node D = new Node(1, null, G);  
            Node C = new Node(9, F, null);  
            Node B = new Node(3, D, E);  
            Node A = new Node(6, B, C);  
            return A;   //返回根节点  
        } 
    
    public void printNode(Node node){  
        System.out.print(node.getData());  
    }
    
    
    public void theFirstTraversal_Stack(Node root) {  //先序遍历  
        Stack<Node> stack = new Stack<Node>();  
        Node node = root;  
        while (node != null || stack.size() > 0) {  //将所有左孩子压栈  
            if (node != null) {   //压栈之前先访问  
                printNode(node);  
                stack.push(node);  
                node = node.getLeftNode();  
            } else {  
                node = stack.pop();  
                node = node.getRightNode();  
            }  
        }  
    }  
      
    public void theInOrderTraversal_Stack(Node root) {  //中序遍历  
        Stack<Node> stack = new Stack<Node>();  
        Node node = root;  
        while (node != null || stack.size() > 0) {  
            if (node != null) {  
                stack.push(node);   //直接压栈  
                node = node.getLeftNode();  
            } else {  
                node = stack.pop(); //出栈并访问  
                printNode(node);  
                node = node.getRightNode(); 
            }  
        }  
    }  
      
    后序遍历递归定义：先左子树，后右子树，再根节点。 
    后序遍历的难点在于：需要判断上次访问的节点是位于左子树，还是右子树。 
    若是位于左子树，则需跳过根节点，先进入右子树，再回头访问根节点； 
    若是位于右子树，则直接访问根节点。
    public void postOrder(Node node){  
        if(node==null)  
            return;  
        Stack<Node> s = new Stack<Node>();  
          
        Node curNode; //当前访问的结点  
        Node lastVisitNode; //上次访问的结点  
        curNode = node;  
        lastVisitNode = null;  
          
        //把currentNode移到左子树的最下边  
        while(curNode!=null){  
            s.push(curNode);  
            curNode = curNode.getLchild();  
        }  
        while(!s.empty()){  
            curNode = s.pop();  //弹出栈顶元素  
            //一个根节点被访问的前提是：无右子树或右子树已被访问过  
            if(curNode.getRchild()!=null&&curNode.getRchild()!=lastVisitNode){  
                //根节点再次入栈  
                s.push(curNode);  
                //进入右子树，且可肯定右子树一定不为空  
                curNode = curNode.getRchild();  
                while(curNode!=null){  
                    //再走到右子树的最左边  
                    s.push(curNode);  
                    curNode = curNode.getLchild();  
                }  
            }else{  
                //访问  
                System.out.println(curNode.getData());  
                //修改最近被访问的节点  
                lastVisitNode = curNode;  
            }  
        } //while  
    }  
    public static void main(String[] args) {  
        BinaryTree1 tree = new BinaryTree1();  
        Node root = tree.init();  
        System.out.println("先序遍历");  
        tree.theFirstTraversal_Stack(root);  
        System.out.println("");  
        System.out.println("中序遍历");  
        tree.theInOrderTraversal_Stack(root);  
        System.out.println("");  
        System.out.println("后序遍历");  
        tree.thePostOrderTraversal_Stack(root);  
        System.out.println("");  
    }
}