Java二叉树（三）--非递归的中序_先序_后序遍历二叉树

二叉树的递归遍历非常简单，但是非递归遍历就需要一点小技巧了，否则代码逻辑容易混乱，这里我给每一个节点定义里加入了一个访问标记flag,这样可以有效避免重复访问和代码逻辑不清楚的问题。

二叉树中序非递归遍历代码如下：

package binarytree;

import java.util.Stack;

/**
 * @author Gavenyeah
 * @date Time: 2016年5月13日上午8:46:38
 * @des: 
 */
//非递归的中序遍历二叉树

public class InOrder{
    public static void main(String args[]){
        Node head = new InOrder().getTree();
        new InOrder().inOrder(head);

    }
    public Node getTree(){
        Node head = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        Node node8 = new Node(8);

        head.left = node2;
        head.right = node3;
        node2.left = node4;
        node2.right = node5;
        node5.left = node7;
        node4.right= node6;
        node7.right= node8;

        return head;

    }
    public void inOrder(Node head){
        Stack<Node> stack  = new Stack<Node>();//用堆栈来实现非递归的中序遍历二叉树
        stack.push(head);
        Node cur = null;
        while(stack.size() > 0){
            head = stack. peek();
            while(head.left != null && head.left.flag == false){//有左子节点且未被访问过
                head = head.left;
                stack.push(head);
            }
            //出栈并访问节点
            cur = stack.pop();
            System.out.print(cur.data+" ");
            cur.flag = true;
            //进一步访问右子节点
            if(cur.right != null){
                stack.push(cur.right);
                head = cur.right;
            }
        }
    }
}

先序非递归遍历：

public void preOrder(Node head) {
        Stack<Node> stack = new Stack<Node>();
        stack.push(head);
        while (stack.size() > 0) {
            head = stack. peek();
            if (head.flag == false) {
                System.out.print(head.data + " ");
                head.flag = true;
            }

            while (head.left != null && head.left.flag == false) {
                head = head.left;
                System.out.print(head.data + " ");
                head.flag = true;
                stack.push(head);
            }
            head = stack.pop();// 没有左子树或左子树已被访问的节点可以直接出栈
            if (head.right != null && head.right.flag == false) {
                head = head.right;
                stack.push(head);
            } 
        }
    }

后序非递归遍历：

public void postOrder(Node head){
        Stack<Node> stack = new Stack<Node>();
        stack.push(head);
        while(stack.size() > 0){
            head = stack.peek();
            while(head.left != null && head.left.flag == false || 
                    head.right != null && head.right.flag == false){
                if(head.right != null && head.right.flag == false){
                    stack.push(head.right);
                }
                if(head.left != null && head.left.flag == false){
                    stack.push(head.left);
                }
                head = stack.peek();
            }
            head = stack.pop();
            System.out.print(head.data + " ");
            head.flag = true;
        }
    }