算法学习02——树(二)树的简单实现

树(二)——树的简单实现

接口

public interface Tree<T extends Comparable<? super T>> {
    class Node<T>{
        T data;
        Node<T> left;
        Node<T> right;
        Node(T t){
            this(t, null, null);
        }
        Node(T t, Node<T> left, Node<T> right){
            this.data = t;
            this.left = left;
            this.right = right;
        }
    }

    void makeEmpty();
    boolean isEmpty();
    boolean contain(T t);
    T findMin();
    T findMax();
    void insert(T t);
    void remove(T t);
    void printTree();
}

泛型T必须要实现Comparable接口，该接口有一个compareTo方法需要实现，这个方法接受一个带有泛型的入参，所以类型参数需要指定为<? super T>。泛型相关内容可见泛型
接口中包含一个静态类Node作为节点数据。
暴露出三种类型的方法：

1. 查询类方法：contain，findMin，finMax。
2. 插入类方法：insert
3. 删除类方法：remove

还有一个遍历方法printTree，在实现中采用了中序遍历

实现类

public class MyTree<T extends Comparable<? super T>> implements Tree<T> {

    private Node<T> root = null;

    public MyTree() {
        this(null);
    }

    public MyTree(Node<T> root) {
        this.root = root;
    }

    @Override
    public void makeEmpty() {
        root = null;
    }

    @Override
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    public boolean contain(T t) {
        return contain(t, root);
    }

    private boolean contain(T t, Node<T> node){
        if (node == null){
            return false;
        }
        int comparaResult = t.compareTo(node.data);
        if (comparaResult < 0){
            return contain(t, node.left);
        }else if (comparaResult > 0){
            return contain(t, node.right);
        }else {
            return true;
        }
    }

    @Override
    public T findMin() {
        return findMin(root);
    }

    private T findMin(Node<T> node){
        if (node == null)
            return null;
        if (node.left == null){
            return node.data;
        }else {
            return findMin(node.left);
        }
    }

    @Override
    public T findMax() {
        return findMax(root);
    }

    private T findMax(Node<T> node){
        if (node == null)
            return null;
        while (node.right != null){
            node = node.right;
        }
        return node.data;
    }

    @Override
    public void insert(T t) {
        root = insert(t, root);
    }

    private Node<T> insert(T t, Node<T> node){
        if (node == null){
            return new Node<>(t, null, null);
        }
        int comparaResult = t.compareTo(node.data);
        if (comparaResult < 0){
            node.left = insert(t, node.left);
        }else if (comparaResult > 0){
            node.right = insert(t, node.right);
        }else ;
        return node;
    }

    @Override
    public void remove(T t) {
        remove(t, root);
    }

    private Node<T> remove(T t, Node<T> node){
        if (node == null){
            return null;
        }
        int comparaResult = t.compareTo(node.data);
        if (comparaResult < 0){
            node.left = remove(t, node.left);
        }else if (comparaResult > 0){
            node.right = remove(t, node.right);
        }else if (node.left != null && node.right != null){
            T data = findMax(node.right);
            node.data = data;
            node.right = remove(data, node.right);
        }else {
            node = (node.left == null) ? node.right: node.left;
        }
        return node;
    }

    @Override
    public void printTree() {
        if (isEmpty()){
            System.out.println("Empty tree");
        }else{
            printTree(root);
            System.out.println();
        }

    }

    private void printTree(Node<T> node){
        if (node != null){
            printTree(node.left);
            System.out.print(node.data + " ");
            printTree(node.right);
        }
    }

}

一些测试例程

public class MyTreeTest {

    @Test
    public void testInsertAndPrint(){
        MyTree<Integer> myTree = new MyTree<>();
        int[] array = Utils.createARandomIntArray();
        for (int i : array){
            myTree.insert(i);
        }
        System.out.println(Arrays.toString(array));
        myTree.printTree();
    }

    @Test
    public void testFindMin(){
        MyTree<Integer> myTree = new MyTree<>();
        int[] array = Utils.createARandomIntArray();
        for (int i : array){
            myTree.insert(i);
        }
        System.out.println(Arrays.toString(array));
        System.out.println(myTree.findMin());
    }

    @Test
    public void testFindMax(){
        MyTree<Integer> myTree = new MyTree<>();
        int[] array = Utils.createARandomIntArray();
        for (int i : array){
            myTree.insert(i);
        }
        System.out.println(Arrays.toString(array));
        System.out.println(myTree.findMax());
    }

    @Test
    public void testContain(){
        MyTree<Integer> myTree = new MyTree<>();
        int[] array = Utils.createARandomIntArray();
        for (int i : array){
            myTree.insert(i);
        }
        System.out.println(Arrays.toString(array));
        int aRandomInt = createARandomInt(-50, 50);
        System.out.println(myTree.contain(aRandomInt));
        System.out.println(aRandomInt);
    }

    @Test
    public void testRemove(){
        MyTree<Integer> myTree = new MyTree<>();
        int[] array = Utils.createARandomIntArray();
        for (int i : array){
            myTree.insert(i);
        }
        System.out.println(Arrays.toString(array));
        myTree.printTree();
        int aRandomInt = createARandomInt(-50, 50);
        while (!myTree.contain(aRandomInt))
            aRandomInt = createARandomInt(-50, 50);
        myTree.remove(aRandomInt);
        myTree.printTree();
    }
}