C++ 在有序地图中实现天花板/地板/低/高

我正在尝试为一个定制的有序映射类实现天花板/地板/较低/较高的函数。目前我有两个语法错误：

“>>应该是>>在嵌套模板中”，我已经以这种方式修改了它，但仍然会出现此错误

“BSIterator不命名类型”

你能告诉我怎么做ceilingEntry吗（它应该返回一个迭代器到最小键值大于或等于k的条目，或者返回end（），如果没有这样的条目或者映射为空）？ 我试着把代码减到最小，我希望它是可以理解的

英国电信公司

#包括
#包括
#包括
模板
类LinkedBinaryTree{
公众：
结构节点{
英语教学；
节点*PAR；
节点*左；
节点*右；
Node（）：elt（），par（NULL），right（NULL），left（NULL）{
};
公众：
阶级地位{
公众：
节点*v；
公众：
位置（节点*_v=NULL）：v（_v）{}
操作员*（）
{return v->elt；}
位置左（）常量
{返回位置（v->左）；}
位置右（）常量
{返回位置（v->右）；}
Position parent（）常量
{返回位置（v->par）；}
bool isRoot（）常量
{return v->par==NULL；}
bool isExternal（）常量
{return v->left==NULL&&v->right==NULL；}
布尔isInternal（）常量
{return！isExternal（）；}
常量E&运算符*（）常量{return v->elt；}
布尔运算符==（const Position&ppos）const{返回此->v==
ppos.v；}
朋友类LinkedBinaryTree；
};
类型定义标准：：列表位置列表；
公众：
LinkedBinaryTree（）；
int getSize（）常量；
bool isEmpty（）常量；
位置根（）常量；
PositionList positions（）常量；
void addRoot（）；
外部（施工位置和p）；
位置移除外部（常量位置和p）；
受保护的：
无效预订单（节点*v、位置列表和pl）常量；
私人：
节点*_根；
int n；
};
模板
LinkedBinaryTree:：LinkedBinaryTree（）
：_根（NULL），n（0）{}
模板
int LinkedBinaryTree:：getSize（）常量
{返回n；}
模板
bool LinkedBinaryTree:：isEmpty（）常量
{return getSize（）==0；}
模板
typename LinkedBinaryTree:：Position LinkedBinaryTree:：root（）常量
{返回位置（_根）；}
模板
void LinkedBinaryTree:：addRoot（）
{u root=新节点；n=1；}
模板
void LinkedBinaryTree:：expandExternal（const Position&p）{
节点*v=p.v；
v->left=新节点；
v->左->标准杆=v；
v->right=新节点；
v->右->标准杆=v；
n+=2；
}
模板
typename LinkedBinaryTree:：Position
LinkedBinaryTree:：removeAboveExternal（常量位置和p）{
节点*w=p.v；节点*v=w->par；
节点*sib=（w==v->左？v->右：v->左）；
if（v==\u根）{
_根=同胞；
sib->par=NULL；
}
否则{
节点*gpar=v->par；
如果（v==gpar->left）gpar->left=sib；
else gpar->right=sib；
sib->par=gpar；
}
删除w；删除v；
n-=2；
返回位置（sib）；
};
模板
typename LinkedBinaryTree:：PositionList LinkedBinaryTree:：positions（）
常数{
职位列表pl；
前序（_根，pl）；
返回位置列表（pl）；
}
模板
void LinkedBinaryTree:：预订单（节点*v、位置列表和pl）常量{
pl.推回（位置（v））；
如果（v->left！=NULL）
预订单（v->左，pl）；
如果（v->右！=NULL）
预订单（v->右，pl）；
}

英国夏令时

模板
班级报名{
公众：
typedef K键；
类型定义V值；
公众：
条目（常数K&K=K（），常数V&V=V（））
：_键（k），_值（v）{}
常量K&key（）常量{return_key；}
常量V&value（）常量{return_value；}
void setKey（常数K&K）{u key=K；}
void setValue（const V&V）{u value=V；}
私人：
K_键；
V_值；
};
//搜索树
模板
类搜索树{
公众：
typedef typename E:：键K；
typedef typename E：：值V；
typedef-LinkedBinaryTree-BinaryTree；
typedef typename LinkedBinaryTree:：Position TPO；
公众：
类迭代器{
公众：
TPos v；
公众：
迭代器（const-TPos&vv）：v（vv）{}
常量E&运算符*（）常量{return*v；}
E&运算符*（）{return*v；}
布尔运算符==（常量迭代器&p）常量{return v==p.v；}
迭代器和运算符++（）；
朋友类搜索树；
};
公众：
SearchTree（）；
int getSize（）常量；
bool isEmpty（）常量；
迭代器查找（常量K&K）；
迭代器插入（常数K&K，常数V&x）；
无效擦除（常数K&K）；
无效擦除（常量迭代器&p）；
迭代器begin（）；
迭代器end（）；
TPos root（）常量；
TPos查找器（常数K&K、常数TPos&v）；
TPos插入器（常数K&K、常数V&x）；
TPos橡皮擦（TPos&v）；
TPO重组（持续TPO&v）；
私人：
二叉树；
int n；
};
模板
int SearchTree:：getSize（）常量{return n；}
模板
bool SearchTree:：isEmpty（）常量{return n==0；}
模板
typename SearchTree:：Iterator&SearchTree:：Iterator:：operator++（）{
TPos w=v.右（）；
if（w.isInternal（））{
do{v=w；w=w.left（）；}
而（w.isintral（））；
}
否则{
w=v.parent（）；
而（v==w.right（））
{v=w；w=w.parent（）；}
v=w；
}
归还*这个；
}
模板
SearchTree:：SearchTree（）：T（），n（0）
{T.addRoot（）；T.expandExternal（T.root（））；}
模板
typename SearchTree:：TPos SearchTree:：root（）常量
{返回T.root（）.left（）；}
模板
typename SearchTree:：迭代器SearchTree:：begin（）{
TPos v=root（）；
而（v.isInternal（））v=v.left（）；
返回迭代器（v.parent（））；
}
模板
typename SearchTree:：迭代器SearchTree:：end（）
{返回迭代器（T.root（））；}
模板
typename SearchTree:：TPos SearchTree:：finder（常数K&K、常数TPos&
（五）{
if（v.isExternal（））返回v；
if（k<（*v.key（））返回查找器（k，v.left（））；
else if（（*v.key（）

OrderedMap.h

#包括“BST.h”
模板
类OrderedMap:公共搜索树{
公众：
类型定义搜索树BST；
typedef typename SearchTree:：迭代器BSTIterator；
typedef typename搜索树：：TPos TPos；
公众：
OrderedMap（）：SearchTree（）{
#include<iostream>
#include<list>
#include<stdio.h>

template <typename E>
class LinkedBinaryTree {

public:
struct Node{
    E elt;
    Node* par;
    Node* left;
    Node* right;
    Node() : elt(), par(NULL), right(NULL), left(NULL){}
};

public:
class Position{
    public:
        Node* v;
    public:
        Position(Node* _v = NULL):v(_v){}
        E& operator*()
            {return v->elt;}
        Position left() const
            {return Position(v->left);}
        Position right() const
            {return Position(v->right);}
        Position parent() const
            {return Position(v->par);}
        bool isRoot() const
            {return v->par == NULL;}
        bool isExternal() const
            {return v->left == NULL && v->right == NULL;}
        bool isInternal() const
            {return !isExternal();}
        const E& operator*() const {return v->elt;}
        bool operator==(const Position& ppos) const { return this->v == 
ppos.v ;}

        friend class LinkedBinaryTree;


};
typedef std::list<Position> PositionList;

public:
LinkedBinaryTree();
int getSize() const;
bool isEmpty() const;
Position root() const;
PositionList positions() const;
void addRoot();
void expandExternal(const Position& p);
Position removeAboveExternal(const Position& p);

protected:
void preorder(Node* v, PositionList& pl) const;
private:
Node* _root;
int n;
};

template <typename E>
LinkedBinaryTree<E>::LinkedBinaryTree()
:_root(NULL), n(0) {}

template <typename E>
int LinkedBinaryTree<E>::getSize() const
{return n;}

template <typename E>
bool LinkedBinaryTree<E>::isEmpty() const
{return getSize() == 0;}

template <typename E>
typename LinkedBinaryTree<E>::Position LinkedBinaryTree<E>::root() const
{return Position(_root);}

template <typename E>
void LinkedBinaryTree<E>::addRoot()
{_root = new Node; n = 1;}

template <typename E>
void LinkedBinaryTree<E>::expandExternal(const Position& p){
Node* v = p.v;
v->left = new Node;
v->left->par = v;
v->right = new Node;
v->right->par = v;
n += 2;
}

template <typename E>
typename LinkedBinaryTree<E>::Position 
LinkedBinaryTree<E>::removeAboveExternal(const Position& p){
Node* w = p.v; Node* v = w->par;
Node* sib = (w==v->left ? v->right:v->left);
if(v == _root){
    _root = sib;
    sib->par = NULL;
}
else{
    Node* gpar = v->par;
    if(v == gpar->left) gpar->left = sib;
    else gpar->right = sib;
    sib->par = gpar;
}
delete w; delete v;
n -= 2;
return Position(sib);
};

template <typename E>
typename LinkedBinaryTree<E>::PositionList LinkedBinaryTree<E>::positions() 
const{
PositionList pl;
preorder(_root, pl);
return PositionList(pl);
}

template <typename E>
void LinkedBinaryTree<E>::preorder(Node* v, PositionList& pl) const{
pl.push_back(Position(v));
if(v->left != NULL)
    preorder(v->left, pl);
if(v->right != NULL)
    preorder(v->right, pl);
}

template<typename K, typename V>
class Entry{
public:
typedef K Key;
typedef V Value;

public:
Entry(const K& k = K(), const V& v = V())
 :_key(k), _value(v) {}
 const K& key() const {return _key;}
 const V& value() const {return _value;}
 void setKey(const K& k) {_key = k;}
 void setValue(const V& v){_value = v;}
private:
K _key;
V _value;
};

//Search Tree
template <typename E>
class SearchTree{

public:
typedef typename E::Key K;
typedef typename E::Value V;
typedef  LinkedBinaryTree<E> BinaryTree;
typedef typename LinkedBinaryTree<E>::Position TPos;

public:
class Iterator{
public:
    TPos v;
public:
    Iterator(const TPos& vv) : v(vv) {}
    const E& operator*() const {return *v;}
    E& operator*() {return *v;}
    bool operator==(const Iterator& p) const {return v == p.v;}
    Iterator& operator++();
    friend class SearchTree;
};

public:
SearchTree();
int getSize() const ;
bool isEmpty() const ;
Iterator find(const K& k);
Iterator insert(const K& k, const V& x);
void erase(const K& k);
void erase(const Iterator& p);
Iterator begin();
Iterator end();
TPos root() const;
TPos finder(const K& k, const TPos& v);
TPos inserter(const K& k, const V& x);
TPos eraser(TPos& v);
TPos restructure(const TPos& v);

private:
BinaryTree T;
int n;
};

template <typename E>
int SearchTree<E>::getSize() const {return n ;}

template <typename E>
bool SearchTree<E>::isEmpty() const {return n==0; }


template <typename E>
typename SearchTree<E>::Iterator& SearchTree<E>::Iterator::operator++(){
TPos w = v.right();
if(w.isInternal()){
    do{v=w; w = w.left();}
    while(w.isInternal());
}
else{
    w = v.parent();
    while(v == w.right())
    {v = w; w = w.parent();}
    v = w;
}
return *this;
}

template <typename E>
SearchTree<E>::SearchTree(): T(), n(0)
{T.addRoot(); T.expandExternal(T.root());}

template <typename E>
typename SearchTree<E>::TPos SearchTree<E>::root() const
{return T.root().left();}

template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::begin(){
TPos v = root();
while (v.isInternal()) v = v.left();
return Iterator(v.parent());
}

template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::end()
{return Iterator(T.root());}

template <typename E>
typename SearchTree<E>::TPos SearchTree<E>::finder(const K& k,  const TPos& 
v){
if(v.isExternal()) return v;
if(k < (*v).key()) return finder(k,v.left());
else if((*v).key() < k) return finder(k,v.right());
else return v;
}

template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::find(const K& k){
TPos v = finder(k, root());
if(v.isInternal()) return Iterator(v);
else return end();
}

#include "BST.h"

template <typename KK, typename VV>
class OrderedMap: public SearchTree<Entry<KK,VV> > {
public:
typedef  SearchTree<Entry<KK,VV> > BST;
typedef typename SearchTree<Entry<KK,VV> >::Iterator BSTIterator;
typedef typename SearchTree<Entry<KK,VV> >::TPos TPos;

public:
OrderedMap(): SearchTree<Entry<KK,VV> >(){}
bool empty () const ;
BSTIterator find ( const KK& k) const {find(k);}
BSTIterator end () {return BST::end();}
BSTIterator ceilingEntry(const KK& k);
BSTIterator ceilingEntry(const KK& k, TPos & w);
//...
};

template <typename KK, typename VV>
BSTIterator OrderedMap<KK,VV>::ceilingEntry(const KK& k) {
if (OrderedMap<KK,VV>::empty()) { return OrderedMap<KK,VV>::end(); }
return ceilingEntry(k, BST.root());
}

template <typename KK, typename VV>
BSTIterator OrderedMap<KK,VV>::ceilingEntry(const KK& k, TPos & w) {
// what to write here?
}