C++ 递归地将一组四叉树节点折叠为其父节点？

我在递归地将四叉树中的一组子节点折叠到其父节点时遇到问题。添加、删除和细分工作正常，但当从树中删除足够的元素时，树不会将未满节点折叠到父节点中，然后删除它们

谢谢

[编辑]

问题解决了这是最后的代码。谢谢各位

#ifndef QUADTREETEST_QUADTREE_H
#define QUADTREETEST_QUADTREE_H

#include <algorithm>
#include <vector>
#include <a2de_graphics.h>
#include <a2de_math.h>

template<typename T>
class QuadTree {

public:
    QuadTree(a2de::Rectangle bounds);
    ~QuadTree();

    bool Add(std::vector<T>& elems);
    bool Add(T& elem);
    bool Remove(T& elem);
    bool Move(T& elem);
    unsigned long Height();
    unsigned long Divisions();
    void Draw(BITMAP* dest);
    unsigned long NumberOfElementsInTree();

    std::vector<T> Query(a2de::Rectangle area);

    std::vector<QuadTree<T>*> GetSiblings(QuadTree<T>* node);
    static unsigned long GetMaxElementsPerNode();
    static void SetMaxElementsPerNode(unsigned long max_elements);

protected:
private:
    enum CHILD_ELEMENTS {
        CHILD_UPPER_LEFT,
        CHILD_UPPER_RIGHT,
        CHILD_LOWER_LEFT,
        CHILD_LOWER_RIGHT,
    };
    static unsigned long MAX_ELEMENTS;
    QuadTree(QuadTree<T>* parent_node, a2de::Rectangle bounds);
    QuadTree(QuadTree<T>* parent_node, a2de::Rectangle bounds, std::vector<T>& elems);
    void SubDivide();
    void UnSubDivide();
    bool IsLeaf(QuadTree<T>* node);
    std::vector<T> QueryNode(QuadTree<T>* node, a2de::Rectangle area);
    bool RemoveElement(T& elem);

    std::vector<T> _elements;
    a2de::Rectangle _bounds;
    QuadTree<T>* _parent;
    std::vector<QuadTree<T>*> _children;

};

template<typename T>
bool QuadTree<T>::Add(std::vector<T>& elems) {
    for(std::vector<T>::iterator _iter = elems.begin(); _iter != elems.end(); ++_iter) {
        this->Add(*_iter);
    }
}

template<typename T>
std::vector<QuadTree<T>*> QuadTree<T>::GetSiblings(QuadTree<T>* node) {

    std::vector<QuadTree<T>*> siblings;

    //Bad pointer.
    if(node == nullptr) return siblings;

    //Root node can't have siblings. Return queried node.
    if(node->_parent == nullptr) {
        siblings.push_back(node);
        return siblings;
    }
    for(std::size_t i = 0; i < 4; ++i) {
        siblings.push_back(_parent->_children[i]);
    }
    return siblings;

}

template<typename T>
std::vector<T> QuadTree<T>::QueryNode(QuadTree<T>* node, a2de::Rectangle area) {
    std::vector<T> contained_elements;
    if(node->_bounds.Intersects(area)) {
        for(std::vector<T>::iterator _iter = _elements.begin(); _iter != _elements.end(); ++_iter) {
            contained_elements.push_back(*_iter);
        }
        if(IsLeaf(node) == false) {
            std::vector<T> ul_elements = QueryNode(_children[CHILD_UPPER_LEFT], area);
            std::vector<T> ur_elements = QueryNode(_children[CHILD_UPPER_RIGHT], area);
            std::vector<T> ll_elements = QueryNode(_children[CHILD_LOWER_LEFT], area);
            std::vector<T> lr_elements = QueryNode(_children[CHILD_LOWER_RIGHT], area);
            for(std::vector<T>::iterator _iter = ul_elements.begin(); _iter != ul_elements.end(); ++_iter) {
                contained_elements.push_back(*_iter);
            }
            ul_elements.clear();

            for(std::vector<T>::iterator _iter = ur_elements.begin(); _iter != ur_elements.end(); ++_iter) {
                contained_elements.push_back(*_iter);
            }
            ur_elements.clear();

            for(std::vector<T>::iterator _iter = ll_elements.begin(); _iter != ll_elements.end(); ++_iter) {
                contained_elements.push_back(*_iter);
            }
            ll_elements.clear();

            for(std::vector<T>::iterator _iter = lr_elements.begin(); _iter != lr_elements.end(); ++_iter) {
                contained_elements.push_back(*_iter);
            }
            lr_elements.clear();
        }
    }
    return contained_elements;
}

template<typename T>
std::vector<T> QuadTree<T>::Query(a2de::Rectangle area) {
    return QueryNode(this, area);
}

template<typename T>
unsigned long QuadTree<T>::MAX_ELEMENTS = 2;

template<typename T>
unsigned long QuadTree<T>::GetMaxElementsPerNode() {
    return MAX_ELEMENTS;
}

template<typename T>
void QuadTree<T>::SetMaxElementsPerNode(unsigned long max_elements) {
    MAX_ELEMENTS = max_elements;
}

template<typename T>
unsigned long QuadTree<T>::NumberOfElementsInTree() {
    if(IsLeaf(this)) return _elements.size();
    unsigned long num_elements = _elements.size();
    for(std::size_t i = 0; i < 4; ++i) {
        num_elements += _children[i]->NumberOfElementsInTree();
    }
    return num_elements;
}

template<typename T>
unsigned long QuadTree<T>::Divisions() {
    if(IsLeaf(this)) return 0;
    unsigned long num_divisions = 4;
    for(std::size_t i = 0; i < 4; ++i) {
        num_divisions += _children[i]->Divisions();
    }
    return num_divisions;
}

template<typename T>
unsigned long QuadTree<T>::Height() {

    if(IsLeaf(this)) return 0;
    unsigned long height = 1;
    for(std::size_t i = 0; i < 4; ++i) {
        height += _children[i]->Height();
    }
    return height;
}

template<typename T>
bool QuadTree<T>::IsLeaf(QuadTree<T>* node) {
    for(std::size_t i = 0; i < 4; ++i) {
        if(node->_children[i] == false) continue;
        return false;
    }
    return true;
}

template<typename T>
QuadTree<T>::~QuadTree() {
    _elements.clear();
    _parent = nullptr;
    for(std::size_t i = 0; i < 4; ++i) {
        delete _children[i];
        _children[i] = nullptr;
    }
}

template<typename T>
void QuadTree<T>::Draw(BITMAP* dest) {
    if(IsLeaf(this)) {
        _bounds.Draw(dest, _bounds.GetColor(), _bounds.IsFilled());
        return;
    }
    for(std::size_t i = 0; i < 4; ++i) {
        _children[i]->Draw(dest);
    }
}

template<typename T>
QuadTree<T>::QuadTree(a2de::Rectangle bounds) : _elements(), _bounds(bounds), _parent(nullptr), _children(4) {
    _bounds.SetColor(a2de::LIME_GREEN);
    _bounds.SetFill(false);
}

template<typename T>
QuadTree<T>::QuadTree(QuadTree<T>* parent_node, a2de::Rectangle bounds) : _elements(), _bounds(bounds), _parent(parent_node), _children(4) {
    _bounds.SetColor(a2de::LIME_GREEN);
    _bounds.SetFill(false);
}

template<typename T>
QuadTree<T>::QuadTree(QuadTree<T>* parent_node, a2de::Rectangle bounds, std::vector<T>& elems) : _elements(elems), _bounds(bounds), _parent(parent_node), _children(4) {
    _bounds.SetColor(a2de::LIME_GREEN);
    _bounds.SetFill(false);
    Add(elems);
}

template<typename T>
void QuadTree<T>::SubDivide() {
    try {
        //Define 
        double half_width = _bounds.GetWidth() / 2.0;
        double half_height = _bounds.GetHeight() / 2.0;
        if(half_width <= 1.0 || half_height <= 1.0) return;

        a2de::Vector2D dimensions(half_width, half_height);
        a2de::Vector2D ul_pos(this->_bounds.GetPosition());
        a2de::Vector2D ur_pos(ul_pos + a2de::Vector2D(half_width, 0.0));
        a2de::Vector2D ll_pos(ul_pos + a2de::Vector2D(0.0, half_height));
        a2de::Vector2D lr_pos(ul_pos + dimensions);
        int color = _bounds.GetColor();
        bool filled = _bounds.IsFilled();

        a2de::Rectangle ul(ul_pos, dimensions, color, filled);
        a2de::Rectangle ur(ur_pos, dimensions, color, filled);
        a2de::Rectangle ll(ll_pos, dimensions, color, filled);
        a2de::Rectangle lr(lr_pos, dimensions, color, filled);

        _children[CHILD_UPPER_LEFT] = new QuadTree(this, ul);
        _children[CHILD_UPPER_RIGHT] = new QuadTree(this, ur);
        _children[CHILD_LOWER_LEFT] = new QuadTree(this, ll);
        _children[CHILD_LOWER_RIGHT] = new QuadTree(this, lr);

        //Give elements of mine to children, may or may not accept them.
        for(std::size_t i = 0; i < 4; ++i) {
            for(std::vector<T>::iterator _iter = _elements.begin(); _iter != _elements.end(); ++_iter) {
                _children[i]->Add(*_iter);
            }
        }
        _elements.clear();

    } catch(...) {
        for(std::size_t i = 0; i < 4; ++i) {
            if(_children[i]) {
                delete _children[i];
                _children[i] = nullptr;
            }
        }
    }
}

template<typename T>
void QuadTree<T>::UnSubDivide() {

    for(std::size_t i = 0; i < 4; ++i) {
        QuadTree<T>* curNode = _children[i];
        QuadTree<T>* curNodeParent = curNode->_parent;
        for(std::vector<T>::iterator _iter = curNode->_elements.begin(); _iter != curNode->_elements.end(); ++_iter) {
            curNodeParent->_elements.push_back(*_iter);
        }
        delete _children[i];
        _children[i] = nullptr;
    }
}

template<typename T>
bool QuadTree<T>::Add(T& elem) {

    if(elem.Intersects(_bounds) == false) return false;

    if(IsLeaf(this) == false) {
        for(std::size_t i = 0; i < 4; ++i) {
            _children[i]->Add(elem);
        }
        return false;
    }
    _elements.push_back(elem);
    if(_elements.size() > MAX_ELEMENTS) {
        SubDivide();
    }
    return true;

}


template<typename T>
bool QuadTree<T>::RemoveElement(T& elem) {
    std::vector<T>::iterator _iter = _elements.begin();
    _iter = std::find(_elements.begin(), _elements.end(), elem);
    if(_iter != _elements.end()) {
        _elements.erase(_iter);
        return true;
    }
    return false;
}


template<typename T>
bool QuadTree<T>::Remove(T& elem) {

    if(elem.Intersects(_bounds) == false) return false;

    if(IsLeaf(this)) {
        return RemoveElement(elem);
    }

    for(std::size_t i = 0; i < 4; ++i) {
        _children[i]->Remove(elem);
    }

    bool all_children_are_leaves = true;
    for(std::size_t i = 0; i < 4; ++i) {
        if(IsLeaf(_children[i])) continue;
        all_children_are_leaves = false;
        break;
    }

    if(all_children_are_leaves) {
        unsigned long elements_in_children = 0;
        for(std::size_t i = 0; i < 4; ++i) {
            elements_in_children += _children[i]->NumberOfElementsInTree();
        }
        if(elements_in_children < MAX_ELEMENTS) {
            UnSubDivide();
        }
    }
    return true;
}

template<typename T>
bool QuadTree<T>::Move(T& elem) {

    return false;
}

#endif

\ifndef QUADTREETEST\u QUADTREE\u H
#定义四叉树测试四叉树
#包括
#包括
#包括
#包括
模板
类四叉树{
公众：
四叉树（a2de:：矩形边界）；
~QuadTree（）；
布尔加法（标准：：向量和元素）；
布尔加（T&elem）；
bool-Remove（T&elem）；
布尔移动（T&elem）；
无符号长高度（）；
无符号长除法（）；
无效绘制（位图*dest）；
无符号长NumberOfElementsInTree（）；
std:：矢量查询（a2de:：矩形区域）；
std:：vector GetSides（四叉树*节点）；
静态无符号长GetMaxElementsPerNode（）；
静态void SetMaxElementsPerNode（无符号长最大元素）；
受保护的：
私人：
枚举子元素{
左上角的孩子，
儿童右上角，
左下角的孩子，
儿童右下角，
};
静态无符号长MAX_元素；
四叉树（四叉树*父节点，a2de:：矩形边界）；
四叉树（四叉树*父节点，a2de:：矩形边界，std:：向量和元素）；
void SubDivide（）；
void UnSubDivide（）；
布尔IsLeaf（四叉树*节点）；
std:：矢量查询节点（四叉树*节点，a2de:：矩形区域）；
布尔移除元素（T&elem）；
std：：矢量元素；
a2de:：矩形_边界；
四叉树*_父；
性病：病媒儿童；
};
模板
布尔四叉树：：添加（标准：：向量和元素）{
对于（std:：vector:：iterator _iter=elems.begin（）；_iter！=elems.end（）；++u iter）{
本->添加（*\u iter）；
}
}
模板
标准：：向量四叉树：：获取同级（四叉树*节点）{
std：：病媒兄弟姐妹；
//指针坏了。
if（node==nullptr）返回同级；
//根节点不能有同级。返回查询的节点。
如果（节点->父节点==nullptr）{
兄弟。推回（节点）；
返回兄弟姐妹；
}
对于（标准：：尺寸\u t i=0；i<4；++i）{
兄弟姐妹。推回（_父->子[i]）；
}
返回兄弟姐妹；
}
模板
std:：vector QuadTree:：QueryNode（四叉树*节点，a2de:：矩形区域）{
包含元素的向量；
if（节点->边界相交（区域））{
对于（std:：vector:：iterator _iter=_elements.begin（）；_iter！=_elements.end（）；++u iter）{
包含元素。推回（*iter）；
}
if（IsLeaf（node）==false）{
std:：vector ul_elements=QueryNode（_children[CHILD_左上角]，区域）；
std:：vector ur_elements=QueryNode（_children[CHILD_右上角]，区域）；
std:：vector ll_elements=QueryNode（_children[CHILD_LOWER_LEFT]，区域）；
std:：vector lr_elements=QueryNode（_children[CHILD_LOWER_RIGHT]，区域）；
对于（std:：vector:：iterator _iter=ul_elements.begin（）；_iter！=ul_elements.end（）；++u iter）{
包含元素。推回（*iter）；
}
ul_元素。清除（）；
对于（std:：vector:：iterator _iter=ur_elements.begin（）；_iter！=ur_elements.end（）；++u iter）{
包含元素。推回（*iter）；
}
ur_元素。清除（）；
对于（std:：vector:：iterator _iter=ll_elements.begin（）；_iter！=ll_elements.end（）；++u iter）{
包含元素。推回（*iter）；
}
ll_元素。清除（）；
对于（std:：vector:：iterator _iter=lr_elements.begin（）；_iter！=lr_elements.end（）；++u iter）{
包含元素。推回（*iter）；
}
lr_元素。清除（）；
}
}
返回包含的元素；
}
模板
标准：：向量四叉树：：查询（a2de：：矩形区域）{
返回QueryNode（此，区域）；
}
模板
无符号长四叉树：：MAX_元素=2；
模板
无符号长四叉树：：GetMaxElementsPerNode（）{
返回MAX_元素；
}
模板
void四叉树：：SetMaxElementsPerNode（无符号长最大元素）{
最大元素=最大元素；
}
模板
无符号长四叉树：：NumberOfElementsInTree（）{
if（IsLeaf（this））返回_elements.size（）；
无符号长num_元素=_元素.size（）；
对于（标准：：尺寸\u t i=0；i<4；++i）{
num_elements+=\u children[i]->NumberOfElementsInTree（）；
}
返回num_元素；
}
模板
无符号长四叉树：：Divisions（）{
if（IsLeaf（this））返回0；
无符号长数字分割=4；
对于（标准：：尺寸\u t i=0；i<4；++i）{
num_divisions+=_children[i]->divisions（）；
}
返回数字除法；
}
模板
无符号长四叉树：：高度（）{
if（IsLeaf（this））返回0；
无符号长高度=1；
对于（标准：：尺寸\u t i=0；i<4；++i）{
身高+=\u儿童[i]->height（）；
}
返回高度；
}
模板
布尔四叉树：：IsLeaf（四叉树*节点）{
对于（标准：：尺寸\u t i=0；i<4；++i）{
如果（node->_children[i]==false）继续；
返回false；
}
返回true；
}
模板
四叉树：：~QuadTree（）{
_元素。清除（）；
_父项=nullptr；
对于（标准：：尺寸\u t i=0；i<4；++i）{
删除_children[i]；
_儿童[i]=nullptr；
}
}
模板
无效四叉树：：绘制（位图*dest）{
如果（IsLeaf（本））{
_绘制（dest，_bounds.GetColor（），_bounds.IsFilled（））；
返回；
}
对于（标准：：尺寸\u t i=0；i<4；++i）{
_儿童[i]->Draw（dest）；
}
}
模板
四叉树：：四叉树（a2de：：矩形边界）：_个元素（），_个边界（边界），_个父元素（nullptr），_个子元素（4）{
_SetColor（a2de:：石灰绿）；
_边界。SetFill（false）；
}
模板
四叉树：：四叉树（四叉树*父节点，a2de：：矩形边界）：\u元素（），\u边界（边界），\u父节点（父节点），\u子节点（4）{
_SetColor（a2de:：石灰绿）；
_边界。SetFill（false）；
}