关于树的非递归算法

package com.lip.datastructure.tree;

import java.util.Stack;
/**
* @author lip
*/
public class Tree
{
public static void main(String[] args)
{
Node<Integer>root=getNode();
System.out.println("前序遍历（非递归）");
preOrder(root);
System.out.println("前序遍历（递归）");
preOrderRecursive(root);
System.out.println();
System.out.println("中序遍历（非递归）");
infixOrder(root);
System.out.println("中序遍历（递归）");
infixOrderRecursive(root);
System.out.println();
System.out.println("后序遍历（非递归）");
postOrder(root);
System.out.println("后序遍历（递归）");
postOrderRecursive(root);

}
public static Node getNode()
{
Node<Integer>node1=new Node(1);
Node<Integer>node2=new Node(2);
Node<Integer>node3=new Node(3);
node1.left=node2;
node1.right=node3;
Node<Integer>node4=new Node(4);
Node<Integer>node5=new Node(5);
node2.left=node4;
node2.right=node5;
Node<Integer>node6=new Node(6);
Node<Integer>node7=new Node(7);
node3.left=node6;
node3.right=node7;
Node<Integer>node8=new Node(8);
Node<Integer>node9=new Node(9);
node4.left=node8;
node4.right=node9;
return node1;
}
//前序遍历，非递归
@SuppressWarnings("rawtypes")
public static void preOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
while(stack.size()>0)
{
Node tempNode=stack.pop();
if(tempNode!=null)
{
System.out.print(tempNode.data);
stack.push(tempNode.right);
stack.push(tempNode.left);
}
}
System.out.println();
}
//前序遍历(根左右)，递归
public static void preOrderRecursive(Node root)
{
if(root!=null)
{
System.out.print(root.data);
preOrderRecursive(root.left);
preOrderRecursive(root.right);
}
}
//中序遍历（左根右），非递归
public static void infixOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
while(stack.size()>0)
{
Node temp=stack.pop();
if(temp!=null)
{
if((temp.left==null)&&(temp.right==null))
System.out.print(temp.data);
else
{
stack.push(temp.right);
stack.push(new Node(temp.data));
stack.push(temp.left);
}
}
}
System.out.println();
}
//中序遍历（左根右），递归
public static void infixOrderRecursive(Node root)
{
if(root!=null)
{
infixOrderRecursive(root.left);
System.out.print(root.data);
infixOrderRecursive(root.right);
}
}
//后序遍历（左右根），非递归
public static void postOrder(Node root)
{
Stack<Node>stack=new Stack<Node>();
stack.push(root);
Node temp;
while(stack.size()>0)
{
temp=stack.pop();
if(temp!=null)
{
if(temp.left==null&&temp.right==null)
System.out.print(temp.data);
else {
stack.push(new Node(temp.data));
stack.push(temp.right);
stack.push(temp.left);
}
}
}
System.out.println();
}
//后序遍历（左右根），递归
public static void postOrderRecursive(Node root)
{
if(root!=null)
{
postOrderRecursive(root.left);
postOrderRecursive(root.right);
System.out.print(root.data);
}
}

}
class Node <T>
{
public Node left;
public Node right;
public T data;
public Node(T data)
{
this.data=data;
}
}