红黑树与迭代器的实现

红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是red或者black，通过对任何一条从根节点到叶子结点上的简单路径来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡。

红黑树具有一下性质
1、每个节点不是红的就是黑的
2、根节点一定是黑的
3、没有连在一起的红色节点
4、从根节点到每个叶子的路径上的黑色节点数目相等

#pragma once
#include <iostream>
using namespace std;

enum COLOR
{
    RED,
    BLACK
};

template<class K,class V>
struct RBTreeNode
{
    RBTreeNode(const K& key = K(), const V& value = V(), COLOR color = RED)
        : _pRight(NULL)
        , _pLeft(NULL)
        , _pParent(NULL)
        , _key(key)
        , _value(value)
        , _color(color)
    {}

    RBTreeNode<K, V>* _pRight;
    RBTreeNode<K, V>* _pLeft;
    RBTreeNode<K, V>* _pParent;
    K _key;
    V _value;
    COLOR _color;
};

template<class K, class V, class Ref, class Ptr>
class RBIterator
{
    typename typedef RBIterator<K, V, Ref, Ptr> self;
    typename typedef RBTreeNode<K, V> Node;
public:
    RBIterator()
    {}

    RBIterator(const self& it)
    {
        _pNode = it._pNode;
    }

    RBIterator(Node* ptmp)
    {
        _pNode = ptmp;
    }

    self& operator++()
    {
        Increment();
        return *this;
    }

    self operator++(int)
    {
        self tmp = *this;
        Increment();
        return tmp;
    }

    self& operator--()
    {
        Decrement();
        return *this;
    }

    self operator--(int)
    {
        self tmp = *this;
        Decrement();
        return tmp;
    }

    bool operator!=(const self& it)
    {
        return _pNode != it._pNode;
    }

    bool operator==(const self& it)
    {
        return _pNode == it._pNode;
    }

    Ref operator*()
    {
        return _pNode->_key;
    }

    Ptr operator->()
    {
        return &(_pNode->_key);
    }

private:
    void Increment()
    {
        if (_pNode->_pRight)
        {
            Node* ptmp = _pNode->_pRight;
            while (ptmp->_pLeft)
                ptmp = ptmp->_pLeft;
            _pNode = ptmp;
        }
        else
        {
            Node* ptmp = _pNode->_pParent;
            while (_pNode == ptmp->_pRight)
            {
                _pNode = ptmp;
                ptmp = ptmp->_pParent;
            }

            if (_pNode->_pRight != ptmp)
                _pNode = ptmp;
        }
    }

    void Decrement()
    {
        if (_pNode->_color == RED  && _pNode->_pParent->_pParent == _pNode)
            _pNode = _pNode->_pLeft;;
        else if (_pNode->_pLeft)
        {
            Node* ptmp = _pNode->_pLeft;
            while (ptmp->_pRight)
                ptmp = ptmp->_pRight;
            _pNode = ptmp;
        }
        else
        {
            Node* ptmp = _pNode->_pParent;
            while (_pNode == ptmp->_pLeft)
            {
                _pNode = ptmp;
                ptmp = ptmp->_pParent;
            }
            _pNode = ptmp;
        }
    }

private:
    Node* _pNode;
};

template<class K, class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    typename typedef RBIterator<K, V, K&, K*> Itetator;
public:

    RBTree()
        :_pRoot(NULL)
    {
        _pHead = new Node; 
        _pHead->_pLeft = _pHead;
        _pHead->_pRight = _pHead;
        _pHead->_pParent = NULL;
    }

    bool Insert(const K& key, const V& value)
    {
        if (NULL == _pRoot)
        {
            _pRoot = new Node(key, value, BLACK);

            _pRoot->_pParent = _pHead;
            _pHead->_pParent = _pRoot;
            _pHead->_pLeft = _pRoot;
            _pHead->_pRight = _pRoot;
            return true;
        }

        Node* pCur = _pRoot;
        Node* pParent = NULL;
        while (pCur)
        {
            if (key == pCur->_key)
                return false;
            else if (key > pCur->_key)
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
            else
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
        }

        pCur = new Node(key, value);
        if (pParent->_key > key)
            pParent->_pLeft = pCur;
        else
            pParent->_pRight = pCur;

        pCur->_pParent = pParent;

        while (pCur && RED == pCur->_color && pParent && RED == pParent->_color)
        {
            Node* pGar = pParent->_pParent;

            if (pParent == pGar->_pLeft)
            {
                Node* pU = pGar->_pRight;

                if (pU && RED == pU->_color)
                {
                    pU->_color = BLACK;
                    pParent->_color = BLACK;
                    pGar->_color = RED;

                    pCur = pGar;
                    pParent = pGar->_pParent;
                }
                else
                {
                    if (pCur == pParent->_pRight)
                    {
                        _RotateL(pParent);

                        std::swap(pParent, pCur);
                    }

                    _RotateR(pGar);

                    pParent->_color = BLACK;
                    pGar->_color = RED;

                    pCur = pParent->_pParent;
                    pParent = pCur->_pParent;
                }
            }
            else
            {
                Node* pU = pGar->_pLeft;

                if (pU && RED == pU->_color)
                {
                    pU->_color = BLACK;
                    pParent->_color = BLACK;
                    pGar->_color = RED;

                    pCur = pGar;
                    pParent = pGar->_pParent;
                }
                else
                {
                    if (pCur == pParent->_pLeft)
                    {
                        _RotateR(pParent);

                        std::swap(pParent, pCur);
                    }

                    _RotateL(pGar);

                    pParent->_color = BLACK;
                    pGar->_color = RED;

                    pCur = pParent->_pParent;
                    pParent = pCur->_pParent;
                }
            }
        }

        _pRoot->_color = BLACK;
        _pHead->_pRight = _GetmaxNode();
        _pHead->_pLeft = _GetminNode();


        return true;
    }

    size_t Size()
    {
        size_t count = 0;
        _Size(_pRoot,count);
        return count;
    }

    Node* Begin()
    {
        return _pHead->_pLeft;
    }

    Node* End()
    {
        return _pHead;
    }

    bool CheckRBTree()
    {
        size_t count = 0;

        _blackCount(_pRoot, count);
        return _CheckRBTree(_pRoot, count, 0);
    }

    void InOrder()
    {
        cout << "InOrder: ";
        _InOrder(_pRoot);
        cout << endl;
    }

private:

    Node* _GetminNode()
    {
        if (NULL == _pRoot)
            return _pRoot;
        Node* pRoot = _pRoot;
        while (pRoot->_pLeft)
            pRoot = pRoot->_pLeft;
        return pRoot;
    }

    Node* _GetmaxNode()
    {   
        if (NULL == _pRoot)
            return _pRoot;
        Node* pRoot = _pRoot;
        while (pRoot->_pRight)
            pRoot = pRoot->_pRight;
        return pRoot;
    }

    void _blackCount(Node* pRoot, size_t &count)
    {
        while (pRoot)
        {
            if (pRoot->_color == BLACK)
                count++;
            pRoot = pRoot->_pLeft;
        }
    }

    void _RotateR(Node* pParent)
    {
        Node* pSubL = pParent->_pLeft;
        Node* pSubLR = pSubL->_pRight;

        pParent->_pLeft = pSubLR;
        if (pSubLR)
            pSubLR->_pParent = pParent;

        pSubL->_pRight = pParent;
        Node* pPParent = pParent->_pParent;
        pParent->_pParent = pSubL;
        pSubL->_pParent = pPParent;
        if (_pHead == pPParent)
        {
            _pRoot = pSubL;
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;
        }
        else
        {
            if (pPParent->_pLeft == pParent)
                pPParent->_pLeft = pSubL;
            else
                pPParent->_pRight = pSubL;
        }
    }

    void _RotateL(Node* pParent)
    {
        Node* pSubR = pParent->_pRight;
        Node* pSubRL = pSubR->_pLeft;

        pParent->_pRight = pSubRL;
        if (pSubRL)
            pSubRL->_pParent = pParent;

        pSubR->_pLeft = pParent;
        Node* pPParent = pParent->_pParent;
        pParent->_pParent = pSubR;
        pSubR->_pParent = pPParent;
        if (_pHead != pPParent)
        {
            if (pPParent->_pLeft == pParent)
                pPParent->_pLeft = pSubR;
            else
                pPParent->_pRight = pSubR;
        }
        else
        {
            _pRoot = pSubR;
            _pHead->_pParent = _pRoot;
            _pRoot->_pParent = _pHead;
        }
    }

    void _InOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            cout << pRoot->_key << ' ';
            _InOrder(pRoot->_pRight);
        }
    }

    bool _CheckRBTree(Node* pRoot, const size_t blackCount, size_t k)
    {
        if (pRoot == NULL)
            return true;

        if (pRoot->_color == BLACK)
            k++;

        if (pRoot->_color == RED && pRoot->_pParent->_color == RED)
            return false;

        if (pRoot->_pLeft == NULL && pRoot->_pRight == NULL)
        {
            if (blackCount == k)
                return true;
        }

        return _CheckRBTree(pRoot->_pLeft, blackCount, k) && _CheckRBTree(pRoot->_pRight, blackCount, k);
    }

    void _Size(Node* pRoot,size_t& count)
    {
        if (pRoot)
        {
            count++;
            _Size(pRoot->_pLeft, count);
            _Size(pRoot->_pRight, count);
        }
    }

private:
    Node* _pRoot;
    Node* _pHead;
};