二叉树

二叉树是个经常使用的数据结构：

 

 /**
  * 二叉树的一个简单实现，从根开始，大于或等于节点的值放入右子树，否则放入左子树
  *
  *
  * @author ma.rl
  *
  */
 public class BinTree {

     private Node root;

     public BinTree() {

     }

     /**
      * @return the root
      */
     public Node getRoot() {
         return root;
     }

     /**
      * @param root
      *            the root to set
      */
     public void setRoot(Node root) {
         this.root = root;
     }

     public void buildTree(int[] a) {
         // 1,2,3,4,5,6
         // 3,1,2,6,5,4
         for (int i : a) {
             insert(root, i);
         }

     }

     /**
      * 插入节点
      *
      * @param node
      * @param i
      */
     public void insert(Node node, int i) {
         if (root == null) {
             root = new Node();
             root.setValue(i);
         } else {
             // 插入
             insertNode(root, i);
         }
     }

     /**
      * 递归查找插入
      * @param node
      * @param i
      */
     public void insertNode(Node node, int i) {
         if (node.getValue() > i) {
             // 查找左子树
             if (node.getLeft() == null) {
                 Node newNode = new Node();
                 newNode.setValue(i);
                 node.setLeft(newNode);
             } else {
                 insertNode(node.getLeft(), i);
             }
         } else {
             // 查找右子树
             if (node.getRight() == null) {
                 Node newNode = new Node();
                 newNode.setValue(i);
                 node.setRight(newNode);
             } else {
                 insertNode(node.getRight(), i);
             }
         }
     }

     /**
      * 先序遍历
      */
     public void preTravelTree(Node node) {
         if (node != null) {
             System.out.println(node.getValue());
             preTravelTree(node.getLeft());
             preTravelTree(node.getRight());
         }
     }

     /**
      * 中序遍历
      */
     public void midTravelTree(Node node) {
         if (node != null) {
             midTravelTree(node.getLeft());
             System.out.println(node.getValue());
             midTravelTree(node.getRight());
         }
     }

     /**
      * 后序遍历
      */
     public void postTravelTree(Node node) {
         if (node != null) {
             System.out.println(node.getValue());
             postTravelTree(node.getLeft());
             postTravelTree(node.getRight());
         }
     }

     /**
      * @param args
      */
     public static void main(String[] args) {
         BinTree binTree = new BinTree();
         // 1,2,3,4,5,6
         // 3,1,2,6,5,4
         int[] a = { 3,1,2,6,5,4 };
         binTree.buildTree(a);
         System.out.println("pre: ");
         binTree.preTravelTree(binTree.getRoot());
         System.out.println("mid: ");
         binTree.midTravelTree(binTree.getRoot());
         System.out.println("post: ");
         binTree.postTravelTree(binTree.getRoot());
     }

 }

 class Node {
     private int value;

     /**
      * @return the value
      */
     public int getValue() {
         return value;
     }

     /**
      * @param value
      *            the value to set
      */
     public void setValue(int value) {
         this.value = value;
     }

     /**
      * @return the left
      */
     public Node getLeft() {
         return left;
     }

     /**
      * @param left
      *            the left to set
      */
     public void setLeft(Node left) {
         this.left = left;
     }

     /**
      * @return the right
      */
     public Node getRight() {
         return right;
     }

     /**
      * @param right
      *            the right to set
      */
     public void setRight(Node right) {
         this.right = right;
     }

     private Node left;
     private Node right;
 }

 

 

pre: 
3
1
2
6
5
4
mid: 
1
2
3
4
5
6
post: 
3
1
2
6
5
4