Fatal编程技术网

C++ 从函数遍历树类

c++

C++ 从函数遍历树类,c++,C++,我有一个树类-请参见下面的内容-我想遍历并从树类外部的函数执行一些处理。为了遍历树，我需要设置一个指向树根的指针。 但是，我无法访问类外的根，因为它是私有的 有没有一种方法可以在不使用getter的情况下优雅地检索根地址，并且不公开根地址 谢谢你的帮助 template <class Key> class IntervalST { private: Interval<Key> *root; bool isRed(Interval<Key> *

我有一个树类-请参见下面的内容-我想遍历并从树类外部的函数执行一些处理。为了遍历树，我需要设置一个指向树根的指针。 但是，我无法访问类外的根，因为它是私有的

有没有一种方法可以在不使用getter的情况下优雅地检索根地址，并且不公开根地址

谢谢你的帮助

template <class Key> class IntervalST
{
private:
    Interval<Key> *root;

    bool isRed(Interval<Key> *interval);
    Interval<Key> *rotateLeft(Interval<Key> *h);
    Interval<Key> *rotateRight(Interval<Key> *h);
    Interval<Key> *put(Interval<Key> *h,Key lo, Key hi, Key val);
    Interval<Key> *moveRedLeft(Interval<Key> *h);
    Interval<Key> *moveRedRight(Interval<Key> *h);
    Interval<Key> *deleteMin(Interval<Key> *h, Key hi);
    Interval<Key> *balance(Interval<Key> *h);
    Interval<Key> *remove(Interval<Key> *h, Key lo, Key hi);
    Interval<Key> *min(Interval<Key> *h);
    Interval<Key> *addDuplicate(Interval<Key> *h, Key hi);
    Interval<Key> *removeDuplicate(Interval<Key> *h, Key low, Key hi);
    Interval<Key> *getPointerToKey(Key low);

    void flipColors(Interval<Key> *h);
    void destroy(Interval<Key> *h);
    void printTree(Interval<Key> *h, int indent);
    Key maxVal(Interval<Key> *h);
    int size(Interval<Key> *h);
    bool isBST(Interval<Key> *x, Key min, Key max);
    inline bool isBST(){return isBST(root,0,0);}
    bool isSizeConsistent(Interval<Key> *x);
    inline bool isSizeConsistent(){return isSizeConsistent(root);}
    bool is23(Interval<Key> *x);
    inline bool is23(){return is23(root);}
    bool isBalanced();
    bool isBalanced(Interval<Key> *x,int black);
    int getKeySize(Key low);
    int compare(Key a, Key b);

public:

    //don't forget to build the constructor
    //and overload the =equal operator
    IntervalST():root(NULL){};
    ~IntervalST();
    void remove(Key lo, Key hi);
    void put(Key lo, Key hi);
    inline int size(){return size(root);}
    inline bool isEmpty(){return root == NULL;}
    void print(int indent = 0);
    void check();

};

模板类间隔
{
私人：
区间*根；
bool isRed（间隔*间隔）；
间隔*rotateLeft（间隔*h）；
间隔*旋转光（间隔*h）；
间隔*put（间隔*h，键lo，键hi，键val）；
间隔*向左移动（间隔*h）；
间隔*moveRedRight（间隔*h）；
间隔*deleteMin（间隔*h，键hi）；
间隔*平衡（间隔*h）；
间隔*移除（间隔*h，键lo，键hi）；
间隔*min（间隔*h）；
间隔*添加重复（间隔*h，键hi）；
间隔*RemovedUpplicate（间隔*h，键低，键高）；
间隔*getPointerToKey（键低）；
无效颜色（间隔*h）；
空洞破坏（间隔*h）；
无效打印树（间隔*h，整数缩进）；
键maxVal（间隔*h）；
整数大小（间隔*h）；
布尔isBST（间隔*x，最小键，最大键）；
内联bool isBST（）{返回isBST（根，0,0）；}
布尔一致（间隔*x）；
inline bool isSizeConsistent（）{返回isSizeConsistent（根）；}
bool为23（间隔*x）；
内联bool is23（）{返回is23（根）；}
布尔是平衡的（）；
布尔是平衡的（间隔*x，整数黑色）；
int getKeySize（键低）；
int比较（键a、键b）；
公众：
//不要忘记构建构造函数
//并重载=相等运算符
IntervalST（）：根（NULL）{}；
~IntervalST（）；
无效删除（键lo，键hi）；
无效卖出（低键、高键）；
内联int size（）{返回大小（根）；}
内联bool isEmpty（）{return root==NULL；}
无效打印（整数缩进=0）；
无效检查（）；
};
您需要的是类的迭代器。它很可能被定义为一个朋友，这样就可以看到它的内部结构。否则，您需要公开访问的方法

详细信息。

您需要的是类的迭代器。它很可能被定义为一个朋友，这样就可以看到它的内部结构。否则，您需要公开访问的方法

详细信息。

您可以添加接受指向树类的函数指针的方法，这样您就可以向它传递一个将在树的每个节点上执行的函子。这将保持遍历树中的封装，同时允许向每个节点上执行的任何函数传递指针

像这样：

void IntervalST::executeOnEachNode(void (*functor)(Interval<Key> node,void* userData),
                                   void *userData = 0)
{
      Interval<Key> node;

      //Loop to traverse your tree stepping through each node
     {
       //Calls functor with supplied user data on specific node ( 
       functor(node,userData);
     }
}

void IntervalST:：executeOnEachNode（void（*functor）（间隔节点，void*userData），
void*userData=0）
{
区间节点；
//循环遍历您的树，逐步遍历每个节点
{
//在特定节点（）上使用提供的用户数据调用functor
函子（节点，用户数据）；
}
}
其中，functor是指向接受一个参数（void*）-userData的函数的指针，如果需要，可以使用该参数将捆绑的附加参数传递给函数

用例（统计所有树节点）：

void countAllNodes（间隔节点，void*附加参数）
{
int*count=静态_转换（附加参数）；
*计数+=1；
}
间隔树；
整数计数（0）；
tree.executeOnEachNode（countAllNodes，reinterpret_cast（&count））；

std:：cout您可以添加一个方法，该方法接受指向树类的函数指针，这样您就可以向它传递一个将在树的每个节点上执行的functor。这将保持遍历树中的封装，同时允许传递指向每个节点上执行的任何函数的指针

像这样：


void IntervalST::executeOnEachNode(void (*functor)(Interval<Key> node,void* userData),
                                   void *userData = 0)
{
      Interval<Key> node;

      //Loop to traverse your tree stepping through each node
     {
       //Calls functor with supplied user data on specific node ( 
       functor(node,userData);
     }
}



void IntervalST:：executeOnEachNode（void（*functor）（间隔节点，void*userData），
void*userData=0）
{
区间节点；
//循环遍历您的树，逐步遍历每个节点
{
//在特定节点（）上使用提供的用户数据调用functor
函子（节点，用户数据）；
}
}


其中，functor是指向接受一个参数（void*）-userData的函数的指针，如果需要，可以使用该参数将捆绑的附加参数传递给函数

用例（统计所有树节点）：


void countAllNodes（间隔节点，void*附加参数）
{
int*count=静态_转换（附加参数）；
*计数+=1；
}
间隔树；
整数计数（0）；
tree.executeOnEachNode（countAllNodes，reinterpret_cast（&count））；

std:：难道我不想修改我的树类。我想将它用作黑盒。添加一个friend方法将“中断”我的黑盒。不，迭代器被定义为容器类的朋友。按照我给你的文档，查看一些现有的STL或Boost容器。我不想修改我的树类。我想将其用作黑盒。添加朋友方法将“中断”我的黑盒。不，迭代器被定义为容器类的朋友。按照我给你的文档，看看一些现有的STL或Boost容器。这听起来就是我要找的！…但我不知道如何做！…你能解释你编辑这个问题的意思吗？或者甚至在mor中给我发一些链接来解释这个想法吗e详细信息-谢谢。请注意，对于每种类型的树遍历，您都需要一个新方法或方法的标志-post order、pre order等@PHONODTS-请参见编辑。想法是在树内实现通用遍历，并允许将指向该方法的任何函数的指针传递给该方法-这将确保作为参数传递的函数将在正如Sean Perry提到的，如果遍历顺序很重要，那么每个遍历顺序都需要实现几个这样的成员。这似乎就是我要寻找的…你有一些链接来解释这个方法吗