二叉树的递归,非递归遍历(java)

 import java.util.Stack;
 import java.util.HashMap;

 public class BinTree {
     private char date;
     private BinTree lchild;
     private BinTree rchild;

     public BinTree(char c) {
         date = c;
     }

     // 先序遍历递归
     public static void preOrder(BinTree t) {
         if (t == null) {
             return;
         }
         System.out.print(t.date);
         preOrder(t.lchild);
         preOrder(t.rchild);
     }

     // 中序遍历递归
     public static void InOrder(BinTree t) {
         if (t == null) {
             return;
         }
         InOrder(t.lchild);
         System.out.print(t.date);
         InOrder(t.rchild);
     }

     // 后序遍历递归
     public static void PostOrder(BinTree t) {
         if (t == null) {
             return;
         }
         PostOrder(t.lchild);
         PostOrder(t.rchild);
         System.out.print(t.date);
     }

     // 先序遍历非递归
     public static void preOrder2(BinTree t) {
         Stack<BinTree> s = new Stack<BinTree>();
         while (t != null || !s.empty()) {
             while (t != null) {
                 System.out.print(t.date);
                 s.push(t);
                 t = t.lchild;
             }
             if (!s.empty()) {
                 t = s.pop();
                 t = t.rchild;
             }
         }
     }

     // 中序遍历非递归
     public static void InOrder2(BinTree t) {
         Stack<BinTree> s = new Stack<BinTree>();
         while (t != null || !s.empty()) {
             while (t != null) {
                 s.push(t);
                 t = t.lchild;
             }
             if (!s.empty()) {
                 t = s.pop();
                 System.out.print(t.date);
                 t = t.rchild;
             }
         }
     }

     // 后序遍历非递归
     public static void PostOrder2(BinTree t) {
         Stack<BinTree> s = new Stack<BinTree>();
         Stack<Integer> s2 = new Stack<Integer>();
         Integer i = new Integer(1);
         while (t != null || !s.empty()) {
             while (t != null) {
                 s.push(t);
                 s2.push(new Integer(0));
                 t = t.lchild;
             }
             while (!s.empty() && s2.peek().equals(i)) {
                 s2.pop();
                 System.out.print(s.pop().date);
             }

             if (!s.empty()) {
                 s2.pop();
                 s2.push(new Integer(1));
                 t = s.peek();
                 t = t.rchild;
             }
         }
     }

     public static void main(String[] args) {
         BinTree b1 = new BinTree('a');
         BinTree b2 = new BinTree('b');
         BinTree b3 = new BinTree('c');
         BinTree b4 = new BinTree('d');
         BinTree b5 = new BinTree('e');

         /**
          *      a
          *     / /
          *    b   c
          *   / /
          *  d   e
          */
         b1.lchild = b2;
         b1.rchild = b3;
         b2.lchild = b4;
         b2.rchild = b5;

         BinTree.preOrder(b1);
         System.out.println();
         BinTree.preOrder2(b1);
         System.out.println();
         BinTree.InOrder(b1);
         System.out.println();
         BinTree.InOrder2(b1);
         System.out.println();
         BinTree.PostOrder(b1);
         System.out.println();
         BinTree.PostOrder2(b1);
     }
 }