java 实现二叉树的遍历

public class Node {
private int data;
private Node left;
private Node right;

public Node(){}

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

public Node(int data, Node left, Node right) {
super();
this.data = data;
this.left = left;
this.right = right;
}

public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}

}

public class BinaryNode{
//前序遍历递归的方式
public void preOrder(Node root){
if(null!=root){
System.out.print(root.getData()+"\t");
preOrder(root.getLeft());
preOrder(root.getRight());
}
}

//前序遍历非递归的方式
public void preOrderNonRecursive(Node  root){
Stack<Node> stack=new Stack<Node>();
while(true){
while(root!=null){
System.out.print(root.getData()+"\t");
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty()) break;
root=stack.pop();
root=root.getRight();
}
}

//中序遍历采用递归的方式
public void inOrder(Node root){
if(null!=root){
inOrder(root.getLeft());
System.out.print(root.getData()+"\t");
inOrder(root.getRight());
}
}

//中序遍历采用非递归的方式
public void inOrderNonRecursive(Node root){
Stack<Node> stack=new Stack<Node>();
while(true){
while(root!=null){
stack.push(root);
root=root.getLeft();
}
if(stack.isEmpty())break;
root=stack.pop();
System.out.print(root.getData()+"\t");
root=root.getRight();
}
}

//后序遍历采用递归的方式
public void postOrder(Node  root){
if(root!=null){
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getData()+"\t");
}
}

//后序遍历采用非递归的方式
public void postOrderNonRecursive(Node root){
Stack<Node> stack=new Stack<Node>();
while(true){
if(root!=null){
stack.push(root);
root=root.getLeft();
}else{
if(stack.isEmpty()) return;

if(null==stack.lastElement().getRight()){
root=stack.pop();
System.out.print(root.getData()+"\t");
while(root==stack.lastElement().getRight()){
System.out.print(stack.lastElement().getData()+"\t");
root=stack.pop();
if(stack.isEmpty()){
break;
}
}
}

if(!stack.isEmpty())
root=stack.lastElement().getRight();
else
root=null;
}
}
}
//层序遍历
public void levelOrder(Node root){
Node temp;
Queue<Node> queue=new LinkedList<Node>();
queue.offer(root);
while(!queue.isEmpty()){
temp=queue.poll();
System.out.print(temp.getData()+"\t");
if(null!=temp.getLeft())
queue.offer(temp.getLeft());
if(null!=temp.getRight()){
queue.offer(temp.getRight());
}
}
}
}

public static void main(String[] args) {
Node node10=new Node(10,null,null);
Node node8=new Node(8,null,null);
Node node9=new Node(9,null,node10);
Node node4=new Node(4,null,null);
Node node5=new Node(5,node8,node9);
Node node6=new Node(6,null,null);
Node node7=new Node(7,null,null);
Node node2=new Node(2,node4,node5);
Node node3=new Node(3,node6,node7);
Node node1=new Node(1,node2,node3);

BinaryNode tree=new BinaryNode();
//采用递归的方式进行遍历
System.out.println("-----前序遍历------");
tree.preOrder(node1);        // 1   2   4   5   8   9   10  3   6   7
System.out.println();
//采用非递归的方式遍历
tree.preOrderNonRecursive(node1);        // 1   2   4   5   8   9   10  3   6   7
System.out.println();

//采用递归的方式进行遍历
System.out.println("-----中序遍历------");
tree.inOrder(node1);    //   4  2   8   5   9   10  1   6   3   7
System.out.println();
//采用非递归的方式遍历
tree.inOrderNonRecursive(node1);    //   4  2   8   5   9   10  1   6   3   7
System.out.println();

//采用递归的方式进行遍历
System.out.println("-----后序遍历------");
tree.postOrder(node1);    //   4    8   10  9   5   2   6   7   3   1
System.out.println();
//采用非递归的方式遍历
tree.postOrderNonRecursive(node1);    //   4    8   10  9   5   2   6   7   3   1
System.out.println();

//采用递归的方式进行遍历
System.out.println("-----层序遍历------");
tree.levelOrder(node1);    //  1    2   3   4   5   6   7   8   9   10
System.out.println();
}