我用Java实现的二叉树的遍历（递归和非递归）

下面是我的原代码，后面是一个辅助类：

/**
 * BinTee.java
 */
package com.zyh.test;
import java.util.*;
/**
 * @author zhyhang
 * @version 10/19/07
 */
public class BinTree {

 /**
  * @param args
  */
 public static void main(String[] args) {

  System.out.println("Please the string of a tree(space indicating null tree:");
  String s=DataStructures.inputString();
  Tree<Character> root=createTreeFromString(s,0);
  if(root!=null)
  {
   System.out.print("The pre order traverse:");
   System.out.println(PreOrderTraverse(root));
   System.out.print("The pre order traverse(not nested simple):");
   System.out.println(PreOrderTraverseNotNestedSimple(root));
   System.out.print("The in order traverse:");
   System.out.println(InOrderTraverse(root));
   System.out.print("The in order traverse(not nested):");
   System.out.println(InOrderTraverseNotNested(root));
   System.out.print("The in order traverse(not nested simple):");
   System.out.println(InOrderTraverseNotNestedSimple(root));
   System.out.print("The post order traverse:");
   System.out.println(PostOrderTraverse(root));
   System.out.print("The post order traverse(not nested):");
   System.out.println(PostOrderTraverseNotNested(root));

  }
 }

 /**
  * Create a binary tree
  * @param s - the string of the tree.
  * <br>space reprensents the tree is null.
  * @return
  */
 public static Tree<Character> createTreeFromString(String s,int i){
  if(s==null || s.length()==0) return null;
  Tree<Character> t=null;
  if(i<s.length() && s.charAt(i)!=' '){
   t=new Tree<Character>();
   t.data=s.charAt(i);
   t.left=createTreeFromString(s,2*i+1);
   t.right=createTreeFromString(s,2*i+2);
  }
  return t;
 }
 
 public static String PreOrderTraverse(Tree<Character> root)
 {
  StringBuilder builder=new StringBuilder();
  if(root!=null) {
   builder.append(root.data);
   builder.append(PreOrderTraverse(root.left));
   builder.append(PreOrderTraverse(root.right));
  }
  return new String(builder);
 }
 
 public static String PreOrderTraverseNotNestedSimple(Tree<Character> root){
  Stack<Tree<Character>> stack=new Stack<Tree<Character>>();
  Tree<Character> p=root;
  StringBuilder builder=new StringBuilder();
  while(p!=null || !stack.empty()){
   if(p!=null){
    builder.append(p.data);
    stack.push(p);
    p=p.left;
   }
   else{
    p=stack.pop().right;
   }
  }
  return new String(builder);
 }
 
 public static String InOrderTraverse(Tree<Character> root)
 {
  StringBuilder builder=new StringBuilder();
  if(root!=null){
   builder.append(InOrderTraverse(root.left));
   builder.append(root.data);
   builder.append(InOrderTraverse(root.right));
  }
  return new String(builder);
 }

 public static String InOrderTraverseNotNested(Tree<Character> root)
 {
  Tree<Character> p=root;
  StringBuilder builder=new StringBuilder();
  Stack<Tree<Character>> stack=new Stack<Tree<Character>>();
  boolean visted=false;
  while(p!=null){
   if(p.left!=null && !visted){
    stack.push(p);
    p=p.left;
   }
   else{
    builder.append(p.data);
    if(p.right!=null) {p=p.right;visted=false;}
    else{
     if(stack.empty()) break;
     else {p=stack.pop();visted=true;}
    }
   }
  }
  return new String(builder);
 }
 
 public static String InOrderTraverseNotNestedSimple(Tree<Character>root){
  StringBuilder builder=new StringBuilder();
  Stack<Tree<Character>> stack=new Stack<Tree<Character>>();
  Tree<Character> p=root;
  while(p!=null || !stack.empty())
  {
   if(p!=null){
    stack.push(p);p=p.left;
   }
   else{
    p=stack.pop();
    builder.append(p.data);
    p=p.right;
   }
  }
  return new String(builder);
 }

 public static String PostOrderTraverse(Tree<Character> root)
 {
  StringBuilder builder=new StringBuilder();
  Tree<Character> p=root;
  if(p!=null){
   builder.append(PostOrderTraverse(p.left));
   builder.append(PostOrderTraverse(p.right));
   builder.append(p.data);
  }
  return new String(builder);
 }
 
 public static String PostOrderTraverseNotNested(Tree<Character> root)
 {
  StringBuilder builder=new StringBuilder();
  Stack<Tree<Character>> stack=new Stack<Tree<Character>>();
  Tree<Character> p=root;
  do{
   if(p!=null){
    stack.push(p);
    p=p.left;
   }
   else
   {
    boolean visited=true;
    Tree<Character> q=null;
    while(visited && !stack.empty()){
     p=stack.get(stack.size() - 1);
     if(p.right==q){
      builder.append(p.data);
      stack.pop();
      q=p;
     }
     else
     {
      p=p.right;
      visited=false;
     }
    }
   }
  }
  while(!stack.empty());
  return new String(builder);
 }
 private static class Tree<T>{
  T data;
  Tree<T> left=null,right=null;
 }
}
 

辅助类文件：

/**
 * DataStructures.java
 */
package com.zyh.test;
import java.util.*;
/**
 * @author zhyhang
 *
 */
public class DataStructures {

 /**
  * @param args
  */
 public static void main(String[] args) {
  //test add list
  System.out.println("Please input some integers for a new list:");
  ZList<Integer> p=inputIntList();
  printList(p);
 }
 
 public static Integer[] inputInt()
 {
  Scanner scan=new Scanner(System.in);
  ArrayList<Integer> a=new ArrayList<Integer>();
  while(scan.hasNextInt())
   a.add(scan.nextInt());
  return a.toArray(new Integer[0]);
 }
 
 public static int[] inputint()
 {
  Integer[] a=inputInt();
  int[] b=new int[a.length];
  for(int i=0;i!=a.length;++i) b[i]=a[i];
  return b;
 }
 
 public static String inputString()
 {
  Scanner scan=new Scanner(System.in);
  if(scan.hasNextLine())
   return scan.nextLine();
  else return "";
 }
 
 public static<T> void printValues(T[] values)
 {
  for(T v:values)
   System.out.print(v+"/t");
  System.out.println();
 }
 
 public static ZList<Integer> inputIntList()
 {
  ZList<Integer> head=null,p=head;
  Scanner sca=new Scanner(System.in);
  while(sca.hasNextInt()){
   Integer i=sca.nextInt();
   if(head==null){
    head=new ZList<Integer>();
    head.data=i;
    p=head;
   }
   else{
    p.next=new ZList<Integer>();
    p.next.data=i;
    p=p.next;
   }
  }
  return head;
  
 }
 public static<T> void printList(ZList<T> head)
 {
  ZList<T> p=head;
  while(p!=null){
   System.out.print(p.data+"->");
   p=p.next;
  }
  if(head!=null) System.out.println("end.");
  else System.out.println("null list.");
 }
 /**
  * @author zhyhang
  *
  */
 public final static class ZList<T> {  
  public T data=null;
  public ZList<T> next=null;
  public ZList()
  {
  }
 }
 
}