数据结构：二叉树（JAVA实现）

最近找Java方面的实习，考虑到面试当中可能出现数据结构的考题，于是把大二学完就放下的数据结构重新翻开。

---

先放一段C语言的二叉树实现代码

//定义元数据类型
typedef int TElemType;
//定义二叉树的结点数据结构
typedef struct BiTNode{
  TElemType data;
  struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

那么在Java中 这段代码要怎么实现呢？我采用类的方式，把一个二叉树结点封装为一个类。

//把二叉树的每一个结点定义为一个类
public class BiTNode {
  private int data;                      //元数据
  private BiTNode LeftChild,RightChild;  //左右子树结点，均为BiTNode类型
  public BiTNode(int data){
     this.LeftChild = null;
     this.RightChild = null;
     this.data = data;
  }
  public int getData() {
     return data;
  }
  public void setData(int data) {
     this.data = data;
  }
  public BiTNode getLeftChild() {
     return LeftChild;
  }
  public void setLeftChild(BiTNode leftChild) {
     LeftChild = leftChild;
  }
  public BiTNode getRightChild() {
     return RightChild;
  }
  public void setRightChild(BiTNode rightChild) {
     RightChild = rightChild;
  }
}

然后，二叉树有三种遍历方式，分别为先序遍历，中序遍历，以及后序遍历，在C语言中，我们可以采取递归的方式遍历。这里呢采取两种方法，其实本质上都是递归。第一种是基于C语言版数据结构书上的算法改写的，第二种比较简单，有想法的同学可以留言交流一下两者的不同。

//第一种方法
    public static int PreOrderTraverse(BiTNode a){
        if(a!=null){
          System.out.print(a.getData()+" ");    
          if(PreOrderTraverse(a.getLeftChild())!=0){
              if(PreOrderTraverse(a.getRightChild())!=0){
                  return 1;
              }
          }       
          return 0; //代表初次递归到头了，向上返回0
        }
        else
            return 1;
    }
  //第二种方法
    public static void preOrderTraverse(BiTNode node) {  
        if (node == null)  
            return;  
        System.out.print(node.getData() + " ");  
        preOrderTraverse(node.getLeftChild());  
        preOrderTraverse(node.getRightChild());  
    }  

中序遍历和后序遍历的算法只需要改写一下方法的顺序即可：

    //中序遍历
    public static void InOrderTraverse(BiTNode node) {  
        if (node == null)  
            return;  
        InOrderTraverse(node.getLeftChild());  
        System.out.print(node.getData() + " ");  
        InOrderTraverse(node.getRightChild());  
    }  
    //后序遍历
    public static void PostOrderTraverse(BiTNode node) {  
        if (node == null)  
            return;  
        PostOrderTraverse(node.getLeftChild());  
        PostOrderTraverse(node.getRightChild()); 
        System.out.print(node.getData() + " ");  
    }  

测试数据：

        //建立二叉树
        BiTNode a = new BiTNode(1); 
        a.setLeftChild(new BiTNode(2));
        a.setRightChild(new BiTNode(3));
        a.getLeftChild().setLeftChild(new BiTNode(4));
        a.getLeftChild().setRightChild(new BiTNode(5));
        a.getRightChild().setLeftChild(new BiTNode(6));
        a.getRightChild().setRightChild(new BiTNode(7));
        //遍历
        System.out.println("前序遍历:");
        preOrderTraverse(a);
        System.out.println();
        System.out.println("中序遍历:");
        InOrderTraverse(a);         
        System.out.println();
        System.out.println("后序遍历:");
        PostOrderTraverse(a);

结果：

前序遍历:
1 2 4 5 3 6 7 
中序遍历:
4 2 5 1 6 3 7 
后序遍历:
4 5 2 6 7 3 1