二叉树——Java实现

package struct;
 
interface Tree{
    //插入元素
    void insert(int value);
    //中序遍历
    void inOrder();
    //先序遍历
    void perOrder();
    //后序遍历
    void postOrder();
    //层序遍历
    //void levelOrder();
    //求最小值
    int getMinValue();
    //求最小值
    int getMaxValue();
    //指定元素删除
    boolean delete(int value);
    //求元素个数
    int length();
    //求树的高度
    int height();
}
 
//工厂类
class Factory1{
    //构造函数
    private Factory1(){}
    public static Tree getTreeInstance(){
        return new BinaryTreeImpl();
    }
}
 
class BinaryTreeImpl implements Tree{
    //根节点
    private Node root;
    private int size;
    class Node{
        //定义左子树
        private Node leftChild;
        //定义右子树
        private Node rightChild;
        private int data;
        //以下为构造方法
        public Node(int data){
            this.data = data;
        }
        public Node(Node leftChild, Node rightChild, int data) {
            super();
            this.leftChild = leftChild;
            this.rightChild = rightChild;
            this.data = data;
        }
    }
    
    //插入元素
    public void insert(int data) {
        Node node = new Node(data);
        //空树
        if(root == null){
            root = node;
            root.leftChild = null;
            root.rightChild = null;
            size++;
        }else{
            //非空树
            Node current = root;
            Node parent = null;
            while(true){
                if(data < current.data){
                    parent = current;
                    current = parent.leftChild;
                    //当前元素小于根节点,当前节点为空
                    if(current == null){
                        parent.leftChild = node;
                        size++;
                        break;
                    }
                }else if(data > current.data){
                    parent = current;
                    current = parent.rightChild;
                    //当前元素大于根节点，且当前节点为空，否则继续循环使当前的current为根节点
                    if(current == null){
                        parent.rightChild = node;
                        size++;
                        break;
                    }
                }else{
                    System.out.println("have same data in the binary tree;");
                }
            }//end of  while
        }
    }
    //中序遍历
    public void inOrder() {
        System.out.println("中序遍历：");
        inOrder1(root);
        System.out.println();
    }
    //中序遍历递归函数
    private void inOrder1(Node node){
        if( node == null){
            return;
        }
        inOrder1(node.leftChild);
        display(node);
        inOrder1(node.rightChild);
    }
    
    //打印函数
    private void display(Node node){
        System.out.print(node.data+" ");
    }
    
    //前序遍历
    public void perOrder() {
        System.out.println("前序遍历：");
        perOrder1(root);
        System.out.println();
    }
    //前序遍历递归函数
    private void perOrder1(Node node){
        if(node == null){
            return;
        }
        display(node);
        perOrder1(node.leftChild);
        perOrder1(node.rightChild);
    }
    
    //后序遍历
    public void postOrder() {
        System.out.println("后序遍历：");
        postOrder1(root);
        System.out.println();
    }
    //后续遍历递归函数
    private void postOrder1(Node node){
        if(node == null){
            return;
        }
        postOrder1(node.leftChild);
        postOrder1(node.rightChild);
        display(node);
    }
    //层序遍历
    /*
    public void levelOrder() {
    }
    */
    //求取树中元素最小值
    public int getMinValue() {
        Node node = root;
        //空树无最小元素
        if(root == null){
            return -1;
        }
        Node current = node.leftChild;
        while(true){
            if(current.leftChild == null){
                return current.data;
            }
            current = current.leftChild;
        }
    }
    //求树中最大元素
    public int getMaxValue(){
        Node node = root;
        if(node == null){
            return -1;
        }
        Node current = node.rightChild;
        while(true){
            if(current.rightChild == null){
                return current.data;
            }
            current = current.rightChild;
        }
    }
    //删除树中元素
    public boolean delete(int value) {
        return false;
    }
    //求树中元素个数
    public int length(){
        return size;
    }
    //求树的高度
    public int height(){
        if(root == null){
            return 0;
        }
        return height1(root);
    }
    private int height1(Node node) {
        if(node!=null){
            int lheight = height1(node.leftChild);
            int rheight = height1(node.rightChild);    
            return lheight > rheight ? lheight+1:rheight+1;
        }
        return 0;
    }
}
public class BinaryTree {
    public static void main(String[] args) {
        Tree tree = Factory1.getTreeInstance();
        System.out.println("===============测试insert函数=====================");
        tree.insert(2);
        tree.insert(1);
        tree.insert(5);
        tree.insert(20);
        tree.insert(3);
        tree.insert(7);
        tree.insert(0);
        tree.insert(10);
        System.out.println("\n"+"===============测试length函数====================="+"\n");
        System.out.println(tree.length());
        System.out.println("\n"+"===============测试inOrder函数====================="+"\n");
        tree.inOrder();
        System.out.println("\n"+"===============测试perOrder函数====================="+"\n");
        tree.perOrder();
        System.out.println("\n"+"===============测试postOrder函数====================="+"\n");
        tree.postOrder();
        System.out.println("\n"+"===============测试getMinValue函数====================="+"\n");
        System.out.println(tree.getMinValue());
        System.out.println("\n"+"===============测试getMaxValue函数====================="+"\n");
        System.out.println(tree.getMaxValue());
        System.out.println("\n"+"===============测试height函数====================="+"\n");
        System.out.println(tree.height());
        }
}