分别用递归和非递归方式实现二叉树的先序、中序和后序遍历

【使用java语言实现二叉树的先序、中序和后序 遍历】

首先创建Node节点类数据结构，如下：

public class Node {
    public int value;  
    public Node left; //左节点
    public Node right; //右节点

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

------------------------递归方法实现-------------------------

1、先序遍历函数实现

public void preOrderRecur(Node head){
    if(head == null){
        return;
    }
    System.out.println(head.value+" ");
    preOrderRecur(head.left);
    preOrderRecur(head.right);
}

2、中序遍历函数实现

public void inOrderRecur(Node head){
    if(head==null){
        return;
    }
    inOrderRecur(head.left);
    System.out.print(head.value + " ");
    inOrderRecur(head.right);
}

3、后序遍历函数实现

public void posOrderRecur(Node head){
    if(head == null){
        return;
    }
    posOrderRecur(head.left);
    posOrderRecur(head.right);
    System.out.println(head.value+ " ");
}

---------------------------非递归方法实现----------------------------

1、先序遍历非递归函数实现

public void preOrderUnRecur(Node head){
    System.out.println("pre-order:");
    if(head != null){
        Stack<Node> stack = new Stack<Node>();
        stack.add(head);
        while (!stack.isEmpty()){
            head = stack.pop();
            System.out.println(head.value + " ");
            if(head.right != null){
                stack.push(head.right);
            }
            if(head.left !=null){
                stack.push(head.left);
            }
        }
    }
    System.out.println();
}

2、中序遍历非递归函数实现

public void inOrderUnRecur(Node head){
    System.out.println("in-order:");
    if(head != null ){
        Stack<Node> stack = new Stack<Node>();
        while (!stack.isEmpty()&&head!=null){

            if(head!=null){
                stack.push(head);
                head = head.left;
            }else{
                head = stack.pop();
                System.out.println(head.value + " ");
                head = head.right;
            }
        }
    }
}

3、后序遍历非递归函数实现

方法一，使用两个栈变量进行实现

public void posOrderUnRecur1(Node head){
    System.out.println("pos-order: ");
    if(head!=null){
        Stack<Node> stack1 = new Stack<Node>();
        Stack<Node> stack2 = new Stack<Node>();
        stack1.push(head);
        while (!stack1.isEmpty()){

            head = stack1.pop();
            stack2.push(head);
            if(head.left != null){
                stack1.push(head.left);
            }
            if(head.right !=null){
                stack1.push(head.right);
            }
        }
    }

    System.out.println();
}

方法二，使用1个栈进行实现

public void posOrderUnRecur2(Node h){
    System.out.print("pos-order:");
    if(h != null){
        Stack<Node> stack = new Stack<Node>();
        stack.push(h);
        Node c = null;
        while (!stack.isEmpty()){
            c = stack.peek();
            if(c.left!=null&&h!=c.left&&h!=c.right){
                stack.push(c.left);
            }else if(c.right!=null&&h!=c.right){
                stack.push(c.right);
            }else{
                System.out.print(stack.pop().value+" ");
                h = c;
            }
        }
    }
}