二叉树的创建，递归和非递归遍历

递归的实现很简单，我就不介绍了；下面我就说说非递归遍历

1. 先序非递归遍历

        根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：

     对于任一结点P：

     1)访问结点P，并将结点P入栈;

     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;

     3)直到P为NULL并且栈为空，则遍历结束。

代码片段：

private static void preUnRecursive(node p) {
		// TODO Auto-generated method stub
		Stack<node> stack=new Stack<node>();
		
		while (p!=null||!stack.isEmpty()) {
			while (p!=null) {
				System.out.print(p.val+" ");   //<span style="color:#FF0000;">访问节点</span>
				stack.push(p);
				p=p.left;
			}
			
			if (!stack.isEmpty()) {    
				p=stack.pop();
				p=p.right;
			}
		}
		
	}

2.中序非递归遍历

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

   对于任一结点P，

  1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

  2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

  3)直到P为NULL并且栈为空则遍历结束

代码片段：

private static void inOrderUnRecursive(node p) {
		// TODO Auto-generated method stub
		Stack<node> stack=new Stack<node>();
		
		while (p!=null||!stack.isEmpty()) {
			while (p!=null) {
				stack.push(p);
				p=p.left;
			}
			if (!stack.isEmpty()) {
				p=stack.pop();
				System.out.print(p.val+" ");      //<span style="color:#FF0000;">访问节点</span>
				p=p.right;
			}
		}
	}

细心的同学可能发现了，先序和后序的代码差别很小，仅仅在于访问节点的那一句. 记住了先序那么中序也就记住了。

下面是最难的后序遍历了，其实也没那么难，不要被吓到了。。。。。好好的看下面一段话你就明白了

思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

代码片段：

private static void postUnRecursive(node p) {
		// TODO Auto-generated method stub
		Stack<node> stack=new Stack<node>();
		node pre=null;
		stack.push(p);
		while (!stack.isEmpty()) {
			p=stack.peek();
			if ((p.left==null&&p.right==null)||(pre==p.right)) {// p为叶子节点或者p的右节点刚刚访问过
			
				System.out.print(stack.pop().val+" ");    //出栈并且打印   
				pre=p;                                    //更新pre 
			}else {                                       //将非空右节点和左节点加入栈
				if (p.right!=null) {                 
					stack.push(p.right);
				}
				if (p.left!=null) {
					stack.push(p.left);
				}
				
			}
		}
	}

完整代码：

package 二叉树;

import java.util.Scanner;
import java.util.Stack;
class node{
    node left;
    node right;
    int val;
    public node(int val) {

        this.val=val;
    }
}
public class BinaryTree {
     /**  
     *       1
     *     /   \  
     *    2     3  
     *   / \      / \
     *  4   5     6  7
     *  
     */    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        System.out.println("请输入要创建的树先序遍历（空节点用0代替）-----------");
        node root=    createBinaryTree (in);
        System.out.println("递归先序遍历-----------");
        preRecursive (root);
        System.out.println();
        System.out.println("非递归先序遍历-----------");
        
        preUnRecursive (root);
        System.out.println();
        System.out.println("递归中序遍历-----------");
        inOrderRecursive(root);
        System.out.println();
        System.out.println("非递归中序遍历-----------");
        inOrderUnRecursive(root);
        System.out.println();
        System.out.println("递归后序遍历-----------");
        postRecursive(root);
        System.out.println();
        System.out.println("非递归后序遍历-----------");
        postUnRecursive(root);
    }

    private static void postUnRecursive(node p) {
        Stack<node> stack=new Stack<node>();
        node pre=null;
        stack.push(p);
        
        while (!stack.isEmpty()) {
            p=stack.peek();
            boolean leaf=p.left==null&&p.right==null;
            if (leaf||pre==p.right) {
                System.out.print(stack.pop().val+" ");
                pre=p;
            }else {
                if (p.right!=null ) {
                    stack.push(p.right);
                }
                if (p.left!=null ) {
                    stack.push(p.left);
                }
            }
        }
        
        
        
        
        
    }

    private static void postRecursive(node root) {
        // TODO Auto-generated method stub
        if (root!=null) {
            postRecursive(root.left);
            postRecursive(root.right);
            System.out.print(root.val+" ");
        }
    }

    private static void inOrderUnRecursive(node p) {
        Stack<node> stack=new Stack<node>();
        while (p!=null||!stack.isEmpty()) {
            while (p!=null ) {
                
                stack.push(p);
                p=p.left;
            }
            
            if (!stack.isEmpty()) {
                p=stack.pop();
                System.out.print(p.val+" ");
                p=p.right;
            }
        }
    }

    private static void inOrderRecursive(node root) {
        // TODO Auto-generated method stub
        if (root!=null) {
            inOrderRecursive(root.left);
            System.out.print(root.val+" ");
            inOrderRecursive(root.right);
        }
    }

    private static void preUnRecursive(node p) {
        Stack<node> stack=new Stack<node>();
        while (p!=null||!stack.isEmpty()) {
            while (p!=null ) {
                System.out.print(p.val+" ");
                stack.push(p);
                p=p.left;
            }
            
            if (!stack.isEmpty()) {
                p=stack.pop();
                p=p.right;
            }
        }
    }

    private static void preRecursive(node root) {
        // TODO Auto-generated method stub
        if (root!=null) {
            System.out.print(root.val+" ");
            preRecursive(root.left);
            preRecursive(root.right);
        }
    }

    private static node createBinaryTree(Scanner in) {
        // TODO Auto-generated method stub
        int val=in.nextInt();
        node newNode=null;
        if (val==0) {
            return null;
        }else {
            newNode=new node(val);
            newNode.left=createBinaryTree(in);
            newNode.right=createBinaryTree(in);
        }

        return newNode;

    }

}

测试结果：