java版的二叉树（面向对象思想）

package cn.itcast.domain;
/**
 * 二叉树的操作封装成对象的思想
 * @author Administrator
 *
 */
public class TreeDemo {

    public static void main(String[] args) {
             Tree tree = new Tree();

             tree.init(20);
             tree.insertData(10);
             tree.insertData(25);
             tree.insertData(3);
             tree.insertData(11);
             tree.insertData(23);
             tree.insertData(26);
             tree.insertData(1);
             tree.insertData(9);
             tree.insertData(12);
             tree.insertData(22);
             tree.insertData(24);
             tree.insertData(27);
             tree.insertData(7);
             tree.insertData(5);
             tree.insertData(6);
             tree.insertData(4);
             tree.printTree2();
             System.out.println();
             tree.delete(3);
             tree.printTree2();
    }

}

/**
 * 定义一个数的节点类
 * @author Administrator
 *
 */
class Node{
    public Node(){
        
    }
    public Node(int data,Node leftChild,Node rightChild){
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }
    Node leftChild;
    Node rightChild;
    int data;
}

/**
 * 定义一个树
 * @author Administrator
 *
 */
class Tree{
    private Node first;
    final private static int LEFT = 1;
    final private static int RIGHT = 2;
    final private static int UNDEFINE =-1;
    
    public void init(int data){
        first =new Node(data,null,null);
    }
    
    /**
     * 插入数据
     * 如果数据在二叉树中存在就会提示你，并不会执行操作
     * @param data
     */
    public void insertData(int data){
        Node root = first;
        if(root == null){
            first = new Node(data,null,null);
            return;
        }
        Node temp = findPosition(root,data);
        if(temp.data>data)
            temp.leftChild = new Node(data,null,null);
        else if(temp.data<data)
            temp.rightChild = new Node(data,null,null);
        else
            System.out.println("你插入的数已经在树中存在了");
    }
    
    public void findData(int data){
        Node root = first;
        if(root == null){
            System.out.println("数中没有数据无法查找！");
            return;
        }
        Node temp = findPosition(root,data);
        if(temp.data==data)
            System.out.println("在树中找到了数据");
        else
            System.out.println("在树中没有找到数据");
    }
    
    private Node findPosition(Node node,int data){
        if(node.data>data&&node.leftChild!=null)
            return findPosition(node.leftChild,data);
        if(node.data<data&&node.rightChild!=null)
            return findPosition(node.rightChild, data);
        else
            return node;
    }
    
    /**
     * 采用先序遍历输出所有结果
     */
    public void printTree1(){
        Node root = first;
        if(root ==null){
            System.out.println("没与数据无法输出");
            return;
        }
        printFirstData(root);
    }
    
    private void printFirstData(Node node){
        System.out.print(node.data+"\t");
        if(node.leftChild!=null)
            printFirstData(node.leftChild);
        if(node.rightChild!=null)
            printFirstData(node.rightChild);
    }
    
    /**
     * 采用中序遍历输出所有的结果
     * @param node
     */
    public void printTree2(){
        Node root = first;
        if(root == null){
            System.out.println("没有数据无法输出");
            return;
        }
        printSecondData(root);
    }
    

    private void printSecondData(Node node){
        if(node.leftChild!=null)
            printSecondData(node.leftChild);
        System.out.print(node.data+"\t");
        if(node.rightChild!=null)
            printSecondData(node.rightChild);
    }
    
    /**
     * 采用后序遍历输出所有的结果
     * @param root
     */
    public void printTree3(){
        Node root = first;
        if(root == null){
            System.out.println("没有数据无法输出");
            return;
        }
        printThirdData(root);
    }


    private void printThirdData(Node root) {
         if(root.leftChild!=null)        
             printThirdData(root.leftChild);
         if(root.rightChild!=null)
             printThirdData(root.rightChild);
         System.out.print(root.data);
    }
    
    /**
     *  采用层序遍历输出所有的结果
     *  其实现就是利用队列的思想
     */
    public void printThravel(){
        Node root = first;
        if(root == null){
            System.out.println("没有数据无法输出");
            return;
        }
        Node[] array = new Node[1024];
        int rear=0,front=0;
        array[rear++]=root;
        while(front<rear){
            Node temp = array[front++];
            System.out.print(temp.data+" ");
            if(temp.leftChild!=null)
                array[rear++]=temp.leftChild;
            if(temp.rightChild!=null)
                array[rear++]=temp.rightChild;
        }
    }
    
    /**
     * 二叉树的删除
     * 难点：删除时要确定其父节点在哪，还要确定是在它父节点的左端还是右端
     * 存在从二叉树中删掉不存在不执行操作
     * @param data要删除的数据
     */
    public void delete(int data){
        Node node = first;
        if(node==null){
            System.out.println("没有数据没法执行删除操作");
            return;
            }
        if(node.data ==data&&node.leftChild==null&&node.rightChild==null){
            first = null;
            return;
        }
        Node parent = first;
        delete1(parent,UNDEFINE,node,data);
        
    }

    /**
     *
     * @param parent 每次变量节点的父节点
     * @param position 每次节点到父节点是左还是右孩子
     * @param node 每次变量的节点
     * @param data 要删的数据值
     */
    private void delete1(Node parent, int position, Node node, int data) {
                      if(node.data>data&&node.leftChild!=null)        
                          delete1(node,LEFT,node.leftChild,data);
                      if(node.data<data&&node.rightChild!=null)
                          delete1(node,RIGHT,node.rightChild,data);
                      if(node.data==data)
                          delete2(parent,position,node);
    }

    /**
     *
     * @param parent 要删节点的父节点
     * @param position 要删节点到父节点是左还是右孩子
     * @param node 要删的节点
     */
    private void delete2(Node parent, int position, Node node) {
        //要删的节点没有左孩子
                  if(node.leftChild==null){
                      if(position==LEFT)
                          parent.leftChild=node.rightChild;
                      else
                          parent.rightChild=node.rightChild;
                      return;
                  }
          
        //要删的节点没有右孩子
                  if(node.rightChild==null){
                      if(position==LEFT)
                          parent.leftChild=node.leftChild;
                      else
                          parent.rightChild=node.leftChild;
                      return;
                  }
         //要删的节点既有左孩子又有右孩子
                  node.data = changeAndDelete(node,RIGHT,node.rightChild);
                      
    }

    private int changeAndDelete(Node parent, int position, Node node) {
        while(node.leftChild!=null){
            parent = node;
            position = LEFT;
            node=node.leftChild;
        }
        if(position==LEFT)
            parent.leftChild=node.rightChild;
        else
            parent.rightChild = node.rightChild;
        return node.data;
    }

}