C# 实现红黑树

 没有实现删除节点

public class RBTree<K, V> : Map<K, V> where K : System.IComparable<K>
{
    private const bool RED = true;
    private const bool BLACK = false;
    public class Node
    {

        public K key;
        public V value;
        public Node left, right;
        public bool color;
        public Node(K key, V value)
        {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            color = RED;
        }

        public override string ToString()
        {
            return key.ToString() + ":" + value.ToString();
        }
    }
    private Node root;
    private int size;
    public RBTree()
    {
        root = null;
        size = 0;
    }
    private bool isRed(Node node)
    {
        if (node == null)
        {
            return BLACK;
        }
        return node.color;
    }
    /// <summary>
    /// 左旋转
    ///           node                         x
    ///         /    \                      /  \
    ///        T1     x       ------->    node  T3
    ///              /  \                 / \
    ///             T2   T3             T1  T2
    /// </summary>
    /// <param name="node"></param>
    /// <returns></returns>
    private Node leftRotate(Node node)
    {
        Node x = node.right;
        //左旋转
        node.right = x.left;
        x.left = node;
        x.color = node.color;
        node.color = RED;
        return x;
    }
    /// <summary>
    ///  右旋转
    ///             node            x
    ///            / \             / \
    ///           x    T2    ---> y   node
    ///         / \                    / \
    ///        y  T1                  T1  T2
    /// </summary>
    /// <param name="node"></param>
    /// <returns></returns>
    public Node RightRotate(Node node)
    {
        Node x = node.left;
        node.left = x.right;
        x.right = node;

        x.color = node.color;
        node.color = RED;

        return x;
    }

    /// <summary>
    /// 颜色反转
    /// </summary>
    /// <param name="node"></param>
    private void filpColors(Node node)
    {
        node.color = RED;
        node.left.color = BLACK;
        node.right.color = BLACK;
    }

    /// <summary>
    /// 向红黑树添加新的元素
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void add(K key, V value)
    {
        root = add(root, key, value);
        root.color = BLACK;
    }
    /// <summary>
    /// 向以node为跟的二分搜搜树种插入 key value 的元素 递归算法 插入新的节点后为二分搜索树的跟
    /// </summary>
    /// <param name="node"></param>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    private Node add(Node node, K key, V value)
    {
        if (node == null)
        {
            size++;
            return new Node(key, value);
        }
        if (key.CompareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if (key.CompareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else
            node.value = value;
        /// <summary>
        /// 判断是否需要左旋转  右节点是红色 左节点不是红色
        /// </summary>
        /// <returns></returns>
        if (isRed(node.right) && !isRed(node.left))
        {
            node = leftRotate(node);
        }
        ///右旋转
        if (isRed(node.left) && isRed(node.left.left))
        {
            node = RightRotate(node);
        }
        if (isRed(node.left) && isRed(node.right))
        {
            filpColors(node);
        }
        return node;
    }
    /// <summary>
    /// 返回以node 为根节点的二分搜索树种
    /// </summary>
    /// <param name="node"></param>
    /// <param name="key"></param>
    /// <returns></returns>
    private Node GetNode(Node node, K key)
    {
        if (node == null)
        {
            return null;
        }
        if (key.CompareTo(node.key) == 0)
        {
            return node;
        }
        else if (key.CompareTo(node.key) < 0)
        {
            return GetNode(node.left, key);
        }
        else // (key.CompareTo(node.key) < 0)
        {
            return GetNode(node.right, key);
        }
    }
    public bool contains(K key)
    {
        Node node = GetNode(root, key);
        return node != null;
    }

    public V get(K key)
    {
        Node node = GetNode(root, key);
        return node == null ? default(V) : node.value;
    }

    public int getSize()
    {
        return size;
    }

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

    public V remove(K key)
    {
        Node node = GetNode(root, key);
        if (node != null)
        {
            root = remove(root, key);
            return node.value;
        }
        return default(V);
    }
    private Node remove(Node node, K key)
    {
        if (node == null)
            return null;
        if (key.CompareTo(node.key) < 0)
        {
            node.left = remove(node.left, key);
            return node;
        }
        else if (key.CompareTo(node.key) > 0)
        {
            node.right = remove(node.right, key);
            return node;
        }
        else // key ==node.key
        {
            //待删除左子树为空的情况
            if (node.left == null)
            {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            //待删除节点右子树为空的情况
            if (node.right == null)
            {
                Node lefyNode = node.left;
                node.left = null;
                size--;
                return lefyNode;
            }
            // 待删除节点左右孩子均不为空的情况
            //找到比待删除节点大的最小值的节点， 即待删除节点右子树的最小节点
            //用这个节点顶替待删除的节点位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;
            return successor;
        }

    }
    /// <summary>
    /// 返回以node为跟的二分搜索树的最小值所在的节点
    /// </summary>
    /// <param name="node"></param>
    /// <returns></returns>
    private Node minimum(Node node)
    {
        if (node.left == null)
            return node;
        return minimum(node.left);
    }
    /// <summary>
    /// 删除掉以node为跟的二分搜索树种最小的节点
    /// /// </summary>
    /// <param name="node"></param>
    /// <returns>返回删除节点后更新的二分搜索树的根</returns>
    private Node removeMin(Node node)
    {
        if (node.left == null)
        {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
    public void set(K key, V value)
    {
        Node node = GetNode(root, key);
        if (node == null)
        {
            add(key, value);
        }
        else
        {
            node.value = value;
        }
    }
}