JAVA之二叉树源码

    class brnNode<T extends Comparable<T>>{
        //定义根结点,初始化为空结点
        TNode<T> root;
        //定义结点数量,初始化为 0
        private int size = 0;

        //前序遍历
        public void preIterator(TNode<T> node){
            if (node != null){
                System.out.println("==== node.data ==>> " + node.data);
                preIterator(node.left);
                preIterator(node.right);
            }
        }

        //中序遍历
        public void midIterator(TNode<T> node){
            if (node != null){
                midIterator(node.left);
                System.out.println("==== node.data ==>> " + node.data);
                midIterator(node.right);
            }
        }

        //后序遍历
        public void latIterator(TNode<T> node){
            if (node != null) {
                latIterator(node.left);
                latIterator(node.right);
                System.out.println("==== node.data ==>> " + node.data);
            }
        }

        public TNode<T> getIteratorNode(){
            return root;
        }

        //往二叉树中加入结点
        public T putValue(T data){
            //定义一个空结点，表示根结点
            TNode<T> t;
            t = root;
            size++;
            //如果结点为空，则新生成一个结点为根结点
            if (t == null){
                root = new TNode<>(data, null);
                return root.data;
            }
            //如果结点不为空，则根据二叉树的性质先判断结点是左结点还是右结点
            else{
                //保存当前结点
                TNode<T> p;
                p = t;

                int ret = 0;
                //若当前结点不为空，则继续查找、直到为空为止
                while(t != null){
                    //保存当前结点，继续循环
                    p = t;

                    //比较当前数据与新数据
                    ret = data.compareTo(t.data);
                    //若新数据小于当前数据，则为左结点
                    if (ret < 0){
                        t = t.left;
                    }
                    //若新数据大于当前数据，则为右结点
                    else if (ret > 0){
                        t = t.right;
                    }
                    //若新数据等于当前数据，则替换当前数据
                    else{
                        t.data = data;
                        return t.data;
                    }
                }

                //根据当前数据新建结点，并指定父结点
                TNode<T> e = new TNode<>(data, p);
                //若新数据小于当前数据，则将结点赋给左结点
                if (ret < 0){
                    p.left = e;
                }
                //若新数据大于当前数据，则将结点赋给右结点
                else if (ret > 0){
                    p.right = e;
                }
                //返回新结点的值
                return p.data;
            }
        }
        //查询结点是否存在
        public boolean getNode(T data){
            TNode<T> node = getValue(data);
            if (node == null){
                return false;
            }
            else{
                return true;
            }
        }

        //查询当前结点
        public TNode<T> getValue(T data){
            TNode<T> p;
            p = root;
            if (p != null) {
                int ret = 0;
                while (p != null) {
                    ret = data.compareTo(p.data);
                    if (ret < 0) {
                        p = p.left;
                    } 
                    else if (ret > 0) {
                        p = p.right;
                    } 
                    else {
                        return p;
                    }
                }
            }
            return null;
        }

        //查询后继结点
        public TNode<T> getAfterNode(TNode<T> node){
            TNode<T> afterNode = node.right;
            while (afterNode.left != null){
                afterNode = afterNode.left;
            }
            return afterNode;
        }

        //删除结点
        public boolean deleteValue(T data){
            TNode<T> delNode = getValue(data);
            TNode<T> parent = delNode.parent;
            if (delNode != null){
                size--;
                //第一种情况，删除结点没有子结点
                if ((delNode.left == null) && (delNode.right == null)){
                    //删除结点为根结点，根结点置为 null
                    if (delNode == root){
                        root = null;
                    }
                    //删除结点为叶子结点
                    else{
                        //若删除结点为父结点的左子结点，则置父结点的左子结点为 null
                        if (delNode == parent.left){
                            parent.left = null;
                        }
                        //若删除结点为父结点的右子结点，则置父结点的右子结点为 null
                        else{
                            parent.right = null;
                        }
                    }

                    //将删除结点置null， 等GC回收
                    delNode.parent = null;
                    delNode.data = null;
                    return true;
                }
                //第二种情况，删除结点只有左子结点
                else if ((delNode.left != null) && (delNode.right == null)){
                    //删除结点为根结点
                    if (parent == null){
                        delNode.left.parent = null;
                        root = delNode.left;
                    }
                    else{
                        delNode.left.parent = parent;
                        if (delNode == parent.left){
                            parent.left = delNode.left;
                        }
                        else{
                            parent.right = delNode.left;
                        }
                    }

                    delNode.parent = null;
                    delNode.left = null;
                    delNode.data = null;
                    return true;
                }
                //第三中情况，删除结点只有右子结点
                else if ((delNode.left == null) && (delNode.right != null)){
                    //删除结点为根结点
                    if (parent == null){
                        root = delNode.right;
                        delNode.right.parent = null;
                    }
                    else{
                        delNode.right.parent = parent;
                        if (delNode == parent.left){
                            parent.left = delNode.right;
                        }
                        else{
                            parent.right = delNode.right;
                        }
                    }

                    delNode.parent = null;
                    delNode.right = null;
                    delNode.data = null;
                    return true;
                }
                //第四种情况，删除结点有两个子结点
                else {
                    //先查找删除结点的后继结点
                    TNode<T> node = getAfterNode(delNode);
                    delNode.data = node.data;
                    //若后继结点为右子结点,使用右子结点替换被删除结点
                    if (node == delNode.right){
                        //删除结点为根结点
                        if (parent == null) {
                            root = node;
                            node.parent = null;
                        }
                        //若后继结点为右子结点且有右子结点时：
                        // 1、将后继结点的右子结点置为删除结点的右子结点；
                        // 2、将后继结点的右子结点的父结点置为删除结点；
                        if (node.right != null){
                            delNode.right = node.right;
                            node.right.parent = delNode;
                        }
                        //若后继结点为右子结点且没有右子结点时：
                        //置删除结点的右子结点为空；
                        else{
                            delNode.right = null;
                        }
                    }
                    //若后继结点为左子结点时
                    else{
                        //判断后继结点是否有右子结点：
                        // 1、若有右子结点，则将后继结点的右子结点赋值给后继结点的父结点上的左子结点
                        // 2、若没有右子结点，则将后继结点的父结点上的左子结点置 null
                        if (node.right != null){
                            node.parent.left = node.right;
                        }
                        else{
                            node.parent.left = null;
                        }
                    }

                    //将后继结点删除，使用GC回收
                    node.left = null;
                    node.right = null;
                    node.parent = null;
                    node.data = null;
                    return true;
                }
            }

            return false;
        }

        //定义一个嵌套结点类
        static final class TNode<T extends Comparable<T>>{
            //定义结点数据
            private T data;
            //定义结点左指针
            private TNode<T> left;
            //定义结点右指针
            private TNode<T> right;
            //定义父结点
            private TNode<T> parent;

            //定义构造函数,给结点赋值
            TNode(T data, TNode<T> parent){
                this.data = data;
                this.parent = parent;
            }
        }
    }