레드 - 블랙 트리 구현

Question

이것은 위치의 중첩 클래스와 레드 - 블랙 트리 클래스의 내 구현, 노드, 등등 이진 검색 트리, 타점은 :

#include <iostream> 

using namespace std; 

template <typename Key, typename Element> 
class RBTree : public BinarySearchTree<Key, Element, RBItem<Key,Element> > { 
protected:      // local types 
    typedef RBItem<Key, Element>  Item;  // a tree node item 
    typedef BinarySearchTree<Key, Element, Item> BST; // base search tree 
    typedef BST::BTPosition  BTPosition; // a tree position 
public:       // public types 
    typedef BST::Position   Position; // a position 
protected:      // local utilities 
    Color color(const BTPosition& p) const {  // get position's color 
    if (T.isExternal(p)) return BLACK;   // externals are black 
    return p.element().color(); 
    } 
    bool isRed(const BTPosition& p) const   // is p red? 
    { return color(p) == RED; } 
    bool isBlack(const BTPosition& p) const  // is p black? 
    { return color(p) == BLACK; } 
    void setRed(const BTPosition& p)   // make p red 
    { if (T.isInternal(p)) p.element().setColor(RED); } 
    void setBlack(const BTPosition& p)   // make p black 
    { if (T.isInternal(p)) p.element().setColor(BLACK); } 
    void setColor(const BTPosition& p, Color color) // set p's color 
    { if (T.isInternal(p)) p.element().setColor(color); } 
    bool hasTwoExternalChildren(const BTPosition& p) const // 2 external children? 
    { return (T.isExternal(T.leftChild(p)) && 
       T.isExternal(T.rightChild(p))); } 
    bool hasRedChild(const BTPosition& p) const  // does p have red child? 
    { return (isRed(T.leftChild(p)) || isRed(T.rightChild(p))); } 
    // ... (other utilities omitted) 
template <typename Key, typename Element> 
class Item {     // a (key, element) pair 
private: 
    Key  _key;    // key value 
    Element _elem;    // element 
public: 
    Item(const Key& k = Key(), const Element& e = Element()) 
    : _key(k), _elem(e) { }   // constructor 
    const Key& key() const   // gets the key (read only) 
    { return _key; } 
    Element& element()    // gets the element 
    { return _elem; } 
    const Element& element() const  // gets the element (read only) 
    { return _elem; } 
    void setKey(const Key& k)   // sets the key value 
    { _key = k; } 
    void setElement(const Element& e)  // sets the element 
    { _elem = e; } 
}; 
template <typename Key, typename Element, 
      typename BSTItem = Item<Key, Element> > 
class BinarySearchTree { 
protected:      // local types 
    typedef BinaryTree<BSTItem>::Position BTPosition; // a tree position 
public:       // public types 
    class Position {          // a Position 
    private: 
    BTPosition btPos;     // position of node 
    public: 
    Position(const BTPosition &p) : btPos(p) { } // constructor 
    Element& element()     // get element 
     { return btPos.element().element(); } 
    const Key& key() const    // get key (read only) 
     { return btPos.element().key(); } 
    bool isNull() const     // a null position? 
     { return btPos.isNull(); } 
    }; 
protected:      // member data 
    BinaryTree<BSTItem> T;    // the binary tree 
protected:      // local utilities 
    Key key(const BTPosition& p) const   // get position's key 
    { return p.element().key(); } 
          // set a node's item 
    void setItem(const BTPosition& p, const BSTItem& i) const { 
    p.element().setKey(i.key()); 
    p.element().setElement(i.element()); 
    } 
public: 
    BinarySearchTree() : T() { }    // constructor 
    int size() const     // size 
    { return (T.size() - 1)/2; }   // number of internals 
    bool isEmpty() const 
    { return size() == 0; } 
    // ... (insert find, insert, and remove functions here) 
}; 

enum Color {RED, BLACK};    // item colors 
template <typename Key, typename Element> 
class RBItem : public Item<Key,Element> {  // a RBTree item 
private: 
    Color col;      // node color 
public: 
    RBItem(const Key& k = Key(), 
    const Element& e = Element(), Color c = RED) // constructor 
     : Item<Key,Element>(k, e), col(c) { } 
    Color color() const { return col; }   // get color 
    void setColor(Color c) { col = c; }   // set color 
}; 
public: 
    RBTree() : BST() { }     // constructor 
    // ... (insert insertItem() and removeElement() here) 

public: 
    void insertItem(const Key& k, const Element& e) { // insert (key,element) 
    BTPosition z = inserter(k, e);   // insert in base tree 
    if (T.isRoot(z)) 
     setBlack(z);     // root is always black 
    else 
     remedyDoubleRed(z);    // rebalance if needed 
    } 
protected: 
    void remedyDoubleRed(const BTPosition& z) {  // fix double-red z 
    BTPosition v = T.parent(z);    // v is z's parent 
    if (T.isRoot(v) || isBlack(v)) return;  // v is black, all ok 
           // z, v are double-red 
    if (isBlack(T.sibling(v))) {   // Case 1: restructuring 
     v = T.restructure(z); 
     setBlack(v);     // top vertex now black 
     setRed(T.leftChild(v)); setRed(T.rightChild(v)); // children are red 
    } 
    else {      // Case 2: recoloring 
     setBlack(v);     // make v black 
     setBlack(T.sibling(v));    // ..and its sibling 
     BTPosition u = T.parent(v);   // u is v's parent 
     if (T.isRoot(u)) return; 
     setRed(u);     // make u red 
     remedyDoubleRed(u);    // may need to fix u now 
    } 
    } 
public: 
    void removeElement(const Key& k)   // remove using key 
     throw(NonexistentElementException) { 
    BTPosition u = finder(k, T.root());   // find the node 
    if (u.isNull())     // not found? 
     throw NonexistentElementException("Remove nonexistent element"); 
    BTPosition r = remover(u);    // remove u 
    if (T.isRoot(r) || isRed(r) || wasParentRed(r)) 
     setBlack(r);     // fix by color change 
    else      // r, parent both black 
     remedyDoubleBlack(r);    // fix double-black r 
    } 
protected: 
    void remedyDoubleBlack(const BTPosition& r) {  // fix double-black r 
    BTPosition x, y, z; 
    x = T.parent(r); 
    y = T.sibling(r); 
    if (isBlack(y)) { 
     if (hasRedChild(y)) {    // Case 1: restructuring 
     z = redChild(y); 
     Color oldColor = color(x);   // save top vertex color 
     z = T.restructure(z);    // restructure x,y,z 
     setColor(z, oldColor);  setBlack(r); // fix colors 
     setBlack(T.leftChild(z)); setBlack(T.rightChild(z)); 
     } 
     else {      // Case 2: recoloring 
     setBlack(r); setRed(y);    // r=black, y=red 
     if (isBlack(x) && !T.isRoot(x)) 
    remedyDoubleBlack(x);    // fix double-black x 
     setBlack(x); 
     } 
    } 
    else {      // Case 3: adjustment 
     if (y == T.rightChild(x)) z = T.rightChild(y); // z is the grandchild 
     else   z = T.leftChild(y); // ...on same side as y 
     T.restructure(z);     // restructure x,y,z 
     setBlack(y); setRed(x);    // y=black, x=red 
     remedyDoubleBlack(r);    // fix by Case 1 or 2 
    } 
    } 
}; 



int main() 
{ 
    return 0; 
} 

이 문제는 그 컴파일러 발견, 아무도 템플릿과 함께 뭐가 잘못 설명 할 수 있습니까?

hm3.cpp:6:39: error: expected template-name before ‘<’ token 
hm3.cpp:6:39: error: expected ‘{’ before ‘<’ token 
hm3.cpp:6:39: error: expected unqualified-id before ‘<’ token 

Answer 1

일부 코드가 누락

, 여기에 코드의 전체 집합입니다 : http://cpp.datastructures.net/source/ch09.html는 (책 "데이터 구조와 C의 알고리즘 ++"에서)