数代码

二叉树

package zhang.tree.rbtree;

import zhang.tree.rbtree.printer.BinaryTreeInfo;

import java.util.LinkedList;
import java.util.Queue;

public class BinaryTree<E> implements BinaryTreeInfo {
    protected int size;
    protected Node<E> root;


    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        root = null;
        size = 0;
    }


    /*前序遍历*/
    public void preorderTraversal() {
        preorderTraversal(root);        //从根节点开始遍历
    }

    private void preorderTraversal(Node<E> node) {
        if (node == null) return;
        System.out.print(node.element + " ");
        preorderTraversal(node.left);
        preorderTraversal(node.right);
    }

    /*中序遍历          如果遍历的是二叉搜索树，那么则是按照升序输出*/
    public void inorderTraversal() {
        inorderTraversal(root);
    }

    private void inorderTraversal(Node<E> node) {
        if (node == null) return;
        inorderTraversal(node.left);
        System.out.print(node.element + " ");
        inorderTraversal(node.right);
    }

    /*后序遍历*/
    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node<E> node) {
        if (node == null) return;
        postorderTraversal(node.left);
        postorderTraversal(node.right);
        System.out.print(node.element + " ");
    }


    /*访问器*/
    public static abstract class Visitor<E> {   //抽象类在接口的基础上多一个存储成员变量的功能
        boolean stop;
        public abstract boolean visit(E element);      // 如果返回true，就代表停止遍历
    }

    /*访问器实现*/
    /*前序遍历*/
    public void preorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        preorderTraversal(root, visitor);        //从根节点开始遍历
    }

    private void preorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        //System.out.print(node.element+" ");
        //这里vistor.stop为true返回，但最终还是会遍历所有节点 只是能够打印出来的节点受到了限制
        //if (visitor.stop)return;    //打印终止

        visitor.stop = visitor.visit(node.element);
        preorderTraversal(node.left, visitor);
        preorderTraversal(node.right, visitor);
    }

    /*中序遍历          如果遍历的是二叉搜索树，那么则是按照升序输出*/
    public void inorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        inorderTraversal(root, visitor);
    }

    private void inorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;  //递归终止
        inorderTraversal(node.left, visitor);
        //System.out.print(node.element + " ");
        if (visitor.stop) {
            return;
        }          //打印终止
        visitor.stop = visitor.visit(node.element);
        inorderTraversal(node.right, visitor);
    }


    /*后序遍历*/
    public void postorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        postorderTraversal(root, visitor);
    }

    private void postorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return; //递归终止
        postorderTraversal(node.left, visitor);
        postorderTraversal(node.right, visitor);
//        System.out.print(node.element + " ");
        if (visitor.stop) return;            //打印终止
        /*
                ┌──7──┐
                │     │
              ┌─4─┐ ┌─9─┐
              │   │ │   │
            ┌─2─┐ 5 8 ┌─11─┐
            │   │     │    │
            1   3    10    12

         * 1 3 2 5 4 8
         * 1 3 2 5 4 8 9 7
         * 如果这里的打印判断if注释掉   那么还会打印找到元素的根节点  如上图 9 7
         * */
        visitor.stop = visitor.visit(node.element);
    }


    /*层序遍历*/
    public void levelOrdertraversal() {
        if (root == null) return;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);      //将根节点入队

        while (!queue.isEmpty()) {    //只要队列不为空，就不断的取出队列的头节点出来
            Node<E> node = queue.poll();
            System.out.print(node.element + " ");
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }

    }



    protected static class Node<E> {
        E element;
        Node<E> left;
        Node<E> right;
        Node<E> parent;
        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        public boolean isLeft() {
            return left == null && right == null;
        }

        public boolean hasTwoChidren() {
            return left != null && right != null;
        }

        public boolean isLeftChild(){
            return parent != null && this == parent.left ;
        }

        public boolean isRightChild(){
            return parent != null && this == parent.right ;
        }

        public Node<E> sibling(){
//            if(isLeftChild())return parent.right ;
//            if (isRightChild()) return parent.left ;
//            return null ;
            return isLeftChild() ? parent.right : (isRightChild() ? parent.left : null ) ;
        }
        }




    /*递归遍历返回树的高度*/
    public int height() {
        return height(root);
    }

    /*返回某个节点的高度*/
    public int height(Node<E> node) {
        if (node == null) return 0;
        return 1 + Math.max(height(node.left), height(node.right));
    }


    protected Node<E> createNode(E element, Node<E> parent){
        return new Node<E>(element,parent);
    }

    /*层序遍历返回树的高度    迭代*/
    public int levelheight() {

        if (root == null) return 0;

        int height = 0;    //树的高度
        int levelSize = 1; //存储每一层元素数量

        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);      //将根节点入队
        while (!queue.isEmpty()) {    //只要队列不为空，就不断的取出队列的头节点出来

            Node<E> node = queue.poll();
            levelSize--;        //每当从队列中取出一个元素  levelSize减一

            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }

            if (levelSize == 0) {  //即将要访问下一层
                levelSize = queue.size();    //更新要访问层数size()
                height++;
            }

        }
        return height;
    }





    public boolean isCompleteTree() {
        if (root == null) return false;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        boolean left = false;
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (left && !node.isLeft()) {   //要求是叶子节点 但又不是叶子节点 返回false
                return false;
            }
            if (node.hasTwoChidren()) {
                queue.offer(node.left);
                queue.offer(node.right);
            } else if (node.left == null && node.right != null) {
                return false;
            } else {  //后面遍历的节点都必须是叶子节点
                left = true;
            }
        }
        return true;
    }



    /*求前驱节点*/
    protected Node<E> predesessor(Node<E> node) {
        if (node == null) return null;
        Node<E> p = node.left;
        if (p != null) {        // 左子树不为空   绝对是左子树中的最大节点   node.left.right.right.right.right
            while (p.right != null) {    //终止条件  right为null
                p = p.right;
            }
            return p;
        }

        while (node.parent != null && node == node.parent.left) {
            node = node.parent;
        }

        /*来到这里有两种情况
         * node.parent==null
         * node==node.parent.right
         * 所以上面while循环退出了node.parent就是要找的值
         * */
        return node.parent;
    }

    /*求后继节点*/
    protected Node<E> successor(Node<E> node) {
        if (node == null) return null;
        Node<E> p = node.right;
        if (p != null) {        // 右子树不为空   绝对是右子树中的最大节点   node.right.left.left.left
            while (p.left != null) {    //终止条件  left为null
                p = p.left;
            }
            return p;
        }

        while (node.parent != null && node == node.parent.right) {
            node = node.parent;
        }
        return node.parent;
    }






    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> myNode = (Node<E>) node;
//        String parentString = null ;
//        if (myNode.parent != null){
//            parentString = myNode.parent.element.toString();        //返回出parent的值
//        }
        return myNode;     //写的是啥 最后输出的是啥  当然 还有Person的toString()决定
    }



}

公共部分

package zhang.tree.rbtree;

import java.util.Comparator;

public class BBST<E> extends BST<E>{

    public BBST(Comparator<E> comparator) {
        super(comparator);
    }

    public BBST() {
    }

    /*有三个属性
     * grand parent  child  都需要更新它们的parent以及有啥子指向它们*/
    protected void rotateLeft(Node<E> grand){
        Node<E> parent = grand.right ;
        Node<E> child = parent.left ;
        grand.right = child ;                 //grand.right指向child
        parent.left = grand ;                 //parent.left指向grand
        afterRotate(grand,parent,child) ;
    }

    protected void rotateRight(Node<E> grand){
        Node<E> parent = grand.left ;
        Node<E> child = parent.right ;
        grand.left = child;
        parent.right = grand ;
        afterRotate(grand,parent,child) ;
    }

    protected void afterRotate(Node<E> grand,Node<E> parent,Node<E> child){
        //让parent成为子节点
        parent.parent = grand.parent ;        //更新parent的parent
        if (grand.isLeftChild()){
            grand.parent.left = parent ;      //原来指向grand的东东现在指向了parent
        }else if (grand.isRightChild()){
            grand.parent.right = parent ;
        }else {
            root =parent ;
        }
        if (child!=null){
            child.parent = grand ;            //更新child的parent
        }
        grand.parent = parent ;               //更新grand的parent


    }



    /**
     * 统一旋转
     */
    protected void rotate(
            Node<E> r, // 子树的根节点
            Node<E> b, Node<E> c,
            Node<E> d,
            Node<E> e, Node<E> f) {
        // 让d成为这颗子树的根结点
        d.parent = r.parent;
        if(r.isLeftChild()){
            r.parent.left = d;
        }else if(r.isRightChild()){
            r.parent.right = d;
        }else{
            root = d;
        }
        // b-c
        b.right = c;
        if(c!=null){
            c.parent = b;
        }

        // e-f
        f.left = e;
        if(e != null){
            e.parent = f;
        }

        // b-d-f
        d.left = b;
        d.right = f;
        b.parent = d;
        f.parent = d;

    }


}

二叉搜索树

package zhang.tree.rbtree;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

public class BST<E> extends BinaryTree<E> {   //传进来的E一定会实现Comparable这个接口

    private final Comparator<E> comparator;

    public BST(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    public BST() {
        this(null);
    }



    public void add(E element) {
        elementNotNullCheck(element);
        if (root == null) {                             //如果根节点为空，添加的第一个节点
            root = createNode(element,null);    //将传进来的element作为root节点的值，其父节点为null
            size++;
            afterAdd(root);
            return;
        }
        /*
         * 如果添加的不是第一个节点
         * 那么添加步骤
         * 1.找到父节点 parent
         * 2.创建新节点 node
         * 3.parent.left = node 或者 parent.right = node
         *
         * 遇到值相等的元素如何处理？
         * 覆盖旧的值
         * * */
        //从根节点根据element找到它的父节点
        Node<E> parent = null;
        Node<E> node = root;  //假设node是根节点
        int compare = 0;
        while (node != null) {
            compare = compare(element, node.element); //传进来的element和根节点的元素相比较
            parent = node;                            //最后return出去后的parent就是父节点
            if (compare > 0) {                        //element的值大于根节点的值
                node = node.right;                    //根节点等于右节点
            } else if (compare < 0) {                 //element的值小于根节点的值
                node = node.left;                     //根节点等于左节点
            } else {                                  //相等直接返回
                node.element = element;              //传进来的元素覆盖掉原来的元素  比如 相同的年龄但不同的名字
                return;
            }
        }
        //创建新节点成为父节点的左右子树
        Node<E> newNode = createNode(element,parent);
        //compare的值决定插入到父节点的那个位置
        if (compare > 0) {
            parent.right = newNode;     //将创建的新节点赋给父节点的右子树
        } else {
            parent.left = newNode;
        }
        size++;
        //新添加节点之后的处理
        afterAdd(newNode);
    }

    /*添加node时候的调整
    * node 新添加的节点*/
    protected void afterAdd(Node<E> node){
    }

    /*删除node时候的调整
    * node 被删除的节点*/
    protected void afterRemove(Node<E> node){
    }


    public void remove(E element) {
        remove(node(element));          //将传入元素的节点删除
    }

    public void remove(Node<E> node){
        if (node==null) return;
        if (node.hasTwoChidren()){
            Node<E> predesessor = predesessor(node);
            //前驱节点的值覆盖度为2的节点的值
            node.element = predesessor.element;
            //node指向前驱节点(要删除的节点 而前驱节点的度必然为1或者0)
            node =  predesessor;
        }
        //删除node节点（node度必然为1或者0）
        Node<E> replacement = node.left!=null?node.left:node.right ;
        if(replacement!=null){  //度为1
            replacement.parent=node.parent ;    //因为度为1 所以要删除的节点的子节点不能删  它的子节点的parent等于要删除的节点的parent
            if (node.parent == null){
                root = replacement ;
            }else if (node==node.parent.left){
                node.parent.left = replacement ;
            }else{
                node.parent.right = replacement ;
            }
            afterRemove(replacement);      //node.parent这个指针还有用    在AVL数中这段代码没啥子用 但在红黑树中说不定哟
        }else if (node.parent==null){     //node == root  node是叶子节点并且是根节点
            root = null ;
            afterRemove(node);      //在AVL数中这段代码没啥子用 但在红黑树中说不定哟
        }else {     //node是叶子节点但不是根节点
            if (node==node.parent.left){
                node.parent.left = null ;
            }else {
                node.parent.right = null ;
            }
            afterRemove(node);
        }

        size--;

    }


    //根据一个元素查找对应的节点
    private Node<E> node(E element){
        Node<E> node = root ;

        while (node!=null){
            int cmp = compare(element,node.element);
            if (cmp==0){
                return node;
            }
            if (cmp>0){
                node = node.right ;
            }else {
                node = node.left ;
            }
        }

        return null ;
    }


    public boolean contains(E element) {
        return node(element) != null;
    }


    @Override
    public String toString() {

        StringBuilder stringBuilder = new StringBuilder();


        return "BinarySearchTree{" +
                "size=" + size +
                ", root=" + root +
                ", comparator=" + comparator +
                '}';
    }

    /* 默认比较
     * 返回值等于0:e1==e2
     * 返回值大于0:e1>e2
     * 返回值小于0:e1
    private int compare(E e1, E e2) {
        if (comparator != null) {     //如果比较器不为空，优先使用比较器
            return comparator.compare(e1, e2);       //如果不加return还是要有强制比较
        }
        //没比较器 就必须要强制比较  必须具备可比较性
        return ((Comparable<E>) e1).compareTo(e2);//如果强制转化失败，会抛出没有实现Comparable这个接口的错误
    }


    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must be not null");
        }

    }




    public void levelOrder(Visitor<E> visitor) {     //想遍历所有元素   传入visitor就可以了
        if (root == null || visitor == null) return;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);      //将根节点入队
        while (!queue.isEmpty()) {    //只要队列不为空，就不断的取出队列的头节点出来
            Node<E> node = queue.poll();
            //  System.out.print(node.element + " ");       这是原来的逻辑  现在不写死了  允许外界自定义遍历逻辑
            /*访问逻辑，拿到节点想干什么*/
            if (visitor.visit(node.element)) return;        //节点对外不可见    对外可见的都是元素
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }



}

AVL树

package zhang.tree.rbtree;

import java.util.Comparator;

public class AVLTree<E> extends BBST<E> {


    public AVLTree() {
        this(null);
    }

    public AVLTree(Comparator<E> comparator) {
        super(comparator);
    }


    @Override
    protected void afterAdd(Node<E> node) {
        while ((node = node.parent) != null) {  //node.parent为null  退出循环
            if (isBalanced(node)) {      //平衡    更新高度   然后接着遍历就欧了
                updateHeight(node);
            } else {                     //不平衡   恢复平衡
                rebalance(node);
                break;          //整棵树恢复平衡
            }
        }
    }

    @Override
    protected void afterRemove(Node<E> node) {
        while ((node = node.parent) != null) {  //node.parent为null  退出循环
            if (isBalanced(node)) {      //平衡    更新高度   然后接着遍历就欧了
                updateHeight(node);
            } else {                     //不平衡   恢复平衡
                rebalance(node);
            }
        }
    }

    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new AVLNode<E>(element, parent);
    }

    private void rebalance(Node<E> grand) {
        Node<E> parent = ((AVLNode<E>)grand).tallerChild();
        Node<E> node = ((AVLNode<E>)parent).tallerChild();
        if (parent.isLeftChild()){      //parent在左边
            if (node.isLeftChild()){    //LL
                rotateRight(grand);
            }else {     //LR
                rotateLeft(parent);
                rotateRight(grand);
            }
        }else {     //parent在右边
            if(node.isLeftChild()){  //RL
                rotateRight(parent);
                rotateLeft(grand);
            }else {     //RR
                rotateLeft(grand);
            }
        }
    }


    private void rebalance2(Node<E> grand){
        Node<E> parent = ((AVLNode<E>)grand).tallerChild();
        Node<E> node = ((AVLNode<E>)parent).tallerChild();
        if(parent.isLeftChild()){//L
            if(node.isLeftChild()){//LL
                rotate(grand, node, node.right, parent, parent.right, grand);
            }else{//LR
                rotate(grand, parent, node.left, node, node.right, grand);
            }
        }else{//R
            if(node.isLeftChild()){//RL
                rotate(grand, grand, node.left, node, node.right, parent);
            }else{//RR
                rotate(grand, grand, parent.left, parent, node.left, node);
            }
        }
    }


    @Override
    protected void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
        super.afterRotate(grand, parent, child);
        //更新高度
        updateHeight(grand);
        updateHeight(parent);
    }

    @Override
    protected void rotate(Node<E> r, Node<E> b, Node<E> c, Node<E> d, Node<E> e, Node<E> f) {
        super.rotate(r, b, c, d, e, f);
        updateHeight(b);
        updateHeight(f);
        updateHeight(d);
    }

    /*恢复平衡*/
    private boolean isBalanced(Node<E> node) {
        return Math.abs(((AVLNode<E>) node).balanceFactor()) <= 1;
    }

    /*更新高度*/
    private void updateHeight(Node<E> node) {    //传一个节点 更新这个节点的高度
        ((AVLNode<E>) node).updateHeight();      //强转代码放到函数里去实现
    }


    private static class AVLNode<E> extends Node<E> {
        public AVLNode(E element, Node<E> parent) {
            super(element, parent);
        }
        int height = 1;

        /*计算平衡因子*/
        public int balanceFactor() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            return leftHeight - rightHeight;
        }

        private void updateHeight() {
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            height = 1 + Math.max(leftHeight, rightHeight);
        }

        public Node<E> tallerChild(){
            int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
            int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
            if (leftHeight > rightHeight) return left ;
            if (leftHeight < rightHeight) return right ;
            return isLeftChild() ? left : right ;       //若高度相等 parent是grand那一边就返回那一边
        }


    }


}

红黑树

package zhang.tree.rbtree;

import java.util.Comparator;

public class RBTree<E> extends BBST<E> {
    public static final boolean RED = false;
    public static final boolean BLACK = true;


    public RBTree(Comparator<E> comparator) {
        super(comparator);
    }

    public RBTree() {
        this(null);
    }

    @Override
    protected void afterAdd(Node<E> node) {
        Node<E> parent = node.parent;
        if (parent == null) {             //添加的是根节点或者上溢达到了根节点
            black(node);
            return;
        }
        if (isBlack(parent)) return;     //如果父节点是黑色，直接返回
        Node<E> uncle = parent.sibling();
        Node<E> grand = red(parent.parent);
        if (isRed(uncle)) {              //如果叔父节点是红色
            black(parent);
            black(uncle);
            afterAdd(grand);       //将染色后的祖父节点当作新添加的节点
            return;
        }
        //叔父节点不是红色
        if (parent.isLeftChild()) {      //L
//            red(grand) ;
            if (node.isLeftChild()) {    //LL
                black(parent);
            } else {                     //LR
                black(node);
                rotateLeft(parent);
            }
            rotateRight(grand);
        } else {                         //R
//            red(grand) ;
            if (node.isLeftChild()) {    //RL
                black(node);
                rotateRight(parent);
            } else {                     //RR
                black(parent);
            }
            rotateLeft(grand);
        }
    }


    @Override
    protected void afterRemove(Node<E> node) {
        if (isRed(node)) return;    //被删除的节点是红色  直接返回
        //来到这里  删除的node节点是黑色
        if (isRed(node)) {    //取代node的子节点是红色
            black(node);
            return;
        }
        //来到这里  删除的是黑色叶子节点
        //删除的是根节点
        Node<E> parent = node.parent;
        if (parent == null) return;  //如果黑色节点是根节点  直接返回

        //判断被删除的节点是左还是右
        boolean left = parent.left == null || node.isLeftChild() ;      //被当作删除的节点和它父节点还是有连线的
        Node<E> sibling = left ? parent.right : parent.left;   //被删除的节点是左节点那么它的兄弟节点在parent的右边
        if (left) {          //被删除的节点在左边，兄弟节点在右边
            if (isRed(sibling)) {    //兄弟节点是红色
                black(sibling);
                red(parent);
                rotateLeft(parent);
                //更换兄弟
                sibling = parent.right;     //旋转之后兄弟变了
            }
            //来到这里兄弟节点必然是黑色78
            //判断兄弟节点左右子节点颜色      这里兄弟节点如果为空，我们也认定它是黑色
            if (isBlack(sibling.right) && isBlack(sibling.left)) {
                //兄弟节点没有一个红色子节点 所以它不能借东西给你  所以父节点只能向下合并
                boolean parentBlack = isBlack(parent);
                black(parent);
                red(sibling);
                if (parentBlack) {       //parent为空  产生下溢 将parent当作被删除的节点
                    afterRemove(parent);
                }

            } else {         //兄弟至少有一个红色子节点
                if (isBlack(sibling.right)) {
                    rotateRight(sibling);
                    sibling = parent.right;
                }
                color(sibling, colorOf(parent));    //兄弟节点跟随parent的颜色
                black(parent);
                black(sibling.right);
                rotateLeft(parent);
            }

        } else {             //被删除的节点在右边，兄弟节点在左边
            if (isRed(sibling)) {    //兄弟节点是红色
                black(sibling);
                red(parent);
                rotateRight(parent);
                //更换兄弟
                sibling = parent.left;     //旋转之后兄弟变了

            }
            //来到这里兄弟节点必然是黑色
            //判断兄弟节点左右子节点颜色      这里兄弟节点如果为空，我们也认定它是黑色
            if (isBlack(sibling.right) && isBlack(sibling.left)) {
                //兄弟节点没有一个红色子节点 所以它不能借东西给你  所以父节点只能向下合并
                boolean parentBlack = isBlack(parent);
                black(parent);
                red(sibling);
                if (parentBlack) {       //parent为空  产生下溢 将parent当作被删除的节点
                    afterRemove(parent);
                }

            } else {         //兄弟至少有一个红色子节点
                if (isBlack(sibling.left)) {
                    rotateLeft(sibling);
                    sibling = parent.left;
                }
                color(sibling, colorOf(parent));    //兄弟节点跟随parent的颜色
                black(parent);
                black(sibling.left);
                rotateRight(parent);
            }
        }

    }

    public Node<E> color(Node<E> node, boolean color) {
        if (node == null) return node;
        ((RBNode<E>) node).color = color;
        return node;
    }

    private Node<E> red(Node<E> node) {
        return color(node, RED);
    }

    private Node<E> black(Node<E> node) {
        return color(node, BLACK);
    }

    private boolean colorOf(Node<E> node) {
        return node == null ? BLACK : ((RBNode<E>) node).color;
    }

    private boolean isBlack(Node<E> node) {
        return colorOf(node) == BLACK;
    }

    private boolean isRed(Node<E> node) {
        return colorOf(node) == RED;
    }


    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new RBNode<>(element, parent);
    }

    public static class RBNode<E> extends Node<E> {
        boolean color = RED;       //能够尽快满足红黑树的性质

        public RBNode(E element, Node<E> parent) {
            super(element, parent);
        }

        @Override
        public String toString() {
            String str = "";
            if (color == RED) {
                str = "R_";
            }
            return str + element.toString();
        }

    }

}