二叉树以及前序遍历、中序遍历和后序遍历

 

java编写二叉树以及前序遍历、中序遍历和后序遍历

[java]  view plain  copy

 

1. /** 
2.  * 实现二叉树的创建、前序遍历、中序遍历和后序遍历 
3.  **/  
4. package DataStructure;  
5.   
6. /** 
7.  * Copyright 2014 by Ruiqin Sun 
8.  * All right reserved 
9.  * created  on 2014-9-9 下午2:34:15 
10.  **/  
11. public class BinTreeInt {  
12.     private Node root;  
13.       
14.     /** 
15.      * 创建内部节点类 
16.      **/  
17.     private class Node{  
18. //      左节点  
19.         private Node leftChild;  
20. //      右节点  
21.         private Node rightChild;  
22. //      节点对应的值  
23.         private int data;  
24.           
25.         public Node(int data){  
26.             this.leftChild = null;  
27.             this.rightChild = null;  
28.             this.data = data;  
29.         }  
30.     }// class Node  
31.       
32.     public BinTreeInt(){  
33.         root = null;  
34.     }  
35.       
36.     /* 
37.      *递归的创建二叉树 
38.      * */  
39.     public void buildTree(Node node ,int data){  
40.         if (root == null){// 如果根节点为空，创建根节点  
41.             root = new Node(data);  
42.         }else{  
43.             if(data <node.data){//插入到左子树  
44.                 if(node.leftChild == null){//左节点为空，直接创建值为data的左节点  
45.                     node.leftChild = new Node(data);  
46.                 }else{//左节点不为空，调用buildTree函数插到左子树中  
47.                     buildTree(node.leftChild,data);  
48.                 }  
49.             }else{  
50.                 if(node.rightChild == null){  
51.                     node.rightChild = new Node(data);  
52.                 }else{  
53.                     buildTree(node.rightChild,data);  
54.                 }  
55.             }         
56.         }  
57.     }//end buildTree  
58.     /* 
59.      *前序遍历二叉树 
60.      * */  
61.     public void preOrder(Node node){  
62.         if(node != null){  
63.             System.out.print(node.data);  
64.             preOrder(node.leftChild);  
65.             preOrder(node.rightChild);  
66.         }  
67.     }  
68.     /* 
69.      *中序遍历二叉树 
70.      * */  
71.     public void inOrder(Node node){  
72.         if(node != null){  
73.             inOrder(node.leftChild);  
74.             System.out.print(node.data);  
75.             inOrder(node.rightChild);  
76.         }  
77.     }  
78.     /* 
79.      *后序遍历二叉树 
80.      * */  
81.     public void postOrder(Node node){  
82.         if(node != null){  
83.             postOrder(node.leftChild);  
84.             postOrder(node.rightChild);  
85.             System.out.print(node.data);              
86.         }  
87.     }  
88.       
89.     public static void main(String ars[]){  
90.         int[] a={2,4,12,45,21,6,111};  
91.         BinTreeInt binTree = new BinTreeInt();  
92.         for(int i = 0; i<a.length; i++){  
93.             binTree.buildTree(binTree.root, a[i]);  
94.         }  
95.         System.out.print("前序遍历");  
96.         binTree.preOrder(binTree.root);  
97.         System.out.println("");  
98.         System.out.print("中序遍历");  
99.         binTree.inOrder(binTree.root);  
100.         System.out.println("");  
101.         System.out.print("后序遍历");  
102.         binTree.postOrder(binTree.root);  
103.     }  
104. }  

//非递归先序遍历
 public static void preTraverse(BinaryTree root) {
  Stack s = new Stack();
  s.push(root);
  while(!s.isEmpty()) {
   BinaryTree bt = (BinaryTree)s.pop();
   visit(bt);
   if(bt.rchild != null) s.push(bt.rchild);
   if(bt.lchild != null) s.push(bt.lchild);
  }
 }
 
 //非递归中序遍历
 public static void inTraverse(BinaryTree root) {
  Stack s = new Stack();
  BinaryTree p = root;
  while(p!=null || !s.isEmpty()) {
   if(p!=null) {
    s.push(p);
    p = p.lchild;
   }
   else {
    p = (BinaryTree)s.pop();
    visit(p);
    p = p.rchild;
   }
  }
 }
 
 //非递归后序遍历
 public static void postTraverse(BinaryTree root) {
  Stack s = new Stack();
  BinaryTree p = root;
  //pre标记最近出栈的节点，用于判断是否是p节点的右孩子，如果是的话，就可以访问p节点
  BinaryTree pre = p;
  //flag标记是出栈还是继续将左孩子进栈
  boolean flag = true;
  while(p!=null || !s.isEmpty()) {
   if(p!=null && flag) {
    s.push(p);
    p = p.lchild;
   }
   else {
    if(s.isEmpty()) return;
    p = (BinaryTree)s.peek();
    if(p.rchild != null && p.rchild!=pre) {
     p = p.rchild;
     flag = true;
    }
    else {
     p = (BinaryTree)s.pop();
     visit(p);
     flag = false;
     pre = p;
    }
   }
  }
 }
 
 //非递归后序遍历2
 public static void postTraverse2(BinaryTree root) {
  Stack s = new Stack();
  BinaryTree p = root;
  //pre标记最近出栈的节点，用于判断是否是p节点的右孩子，如果是的话，就可以访问p节点
  BinaryTree pre = p;
  while(p!=null || !s.isEmpty()) {
   if(p!=null) {
    s.push(p);
    p = p.lchild;
   }
   else {
    if(s.isEmpty()) return;
    p = (BinaryTree)s.peek();
    if(p.rchild != null && p.rchild!=pre) {
     p = p.rchild;
    }
    else {
     p = (BinaryTree)s.pop();
     visit(p);
     pre = p;
     p = null;
    }