C++ 二叉搜索树递归插入导致堆栈溢出，迭代插入不起作用

我要为类做这个项目，在这个类中，我必须（按顺序）向二叉搜索树中添加10000个元素——除其他外，但这并不是当前被破坏的内容。我的递归插入工作正常，直到3500个元素，然后它中断并导致堆栈溢出。然后我尝试创建一个迭代版本的代码，但它只添加了9999和10000元素。所以我的问题是：

如何使递归插入适用于大量已排序的元素？ 或者我如何让我的迭代插入工作呢

我的代码在这里：

递归：

template <typename T>
void BST<T>::insert(BST_Node<T>*& node, const T& data)
{
    if (node == NULL)
    {
        node = new BST_Node<T>(data);
        return;
    }

    if (node->mData == data)
    {
        cout << "Node already exists!" << endl;
        return;
    }

    if (data < node->mData)
        insert(node->mLeft, data);
    else
        insert(node->mRight, data);
}

模板
void BST:：insert（BST_节点*&节点，常量T&数据）
{
if（node==NULL）
{
节点=新的BST_节点（数据）；
返回；
}
如果（节点->mData==数据）
{
cout-mLeft，数据）；
其他的
插入（节点->右侧，数据）；
}

迭代：

template <typename T>
void BST<T>::insertIterative(BST_Node<T>*& node, const T& data)
{
    if (node == NULL)
    {
        node = new BST_Node<T>(data);
        return;
    }    

    while (node != NULL)
    {
        if (data < node->mData)
        {
            if (node->mLeft == NULL)
            {
            node->mLeft = new BST_Node<T>(data);
            return;
        }
        else
            node = node->mLeft;
    }
    else if (data > node->mData)
    {
        if (node->mRight == NULL)
        {
            node->mRight = new BST_Node<T>(data);
            return;
        }
        else
            node = node->mRight;
    }
}

模板
void BST:：插入式（BST_节点*&节点，常量T&数据）
{
if（node==NULL）
{
节点=新的BST_节点（数据）；
返回；
}    
while（节点！=NULL）
{
if（数据mData）
{
如果（节点->mLeft==NULL）
{
节点->mLeft=新的BST_节点（数据）；
返回；
}
其他的
node=node->mLeft；
}
else if（数据>节点->mData）
{
如果（节点->mRight==NULL）
{
节点->mRight=新的BST_节点（数据）；
返回；
}
其他的
节点=节点->右侧；
}
}

此外，如果需要，下面是我的公共插入函数：

template <typename T>
void BST<T>::insert(T data)
{
    insert(mRootNode, data); //insertIterative(mRootNode, data);
}

模板
void BST:：插入（T数据）
{
插入（mRootNode，数据）；//插入（mRootNode，数据）；
}

最后，这里是递归代码中断时出现的错误：

PA7.exe中0x7717CF87（ntdll.dll）处未处理的异常：0xC00000FD:堆栈溢出（参数：0x00000001、0x006F2FF0）

我的BST_节点构造函数：

template <typename T>
struct BST_Node
{
    T           mData;
    BST_Node<T> *mLeft, *mRight;

    BST_Node();
    BST_Node(T data);
    BST_Node(T data, BST_Node<T> *left, BST_Node<T> *right);
};

template <typename T>
BST_Node<T>::BST_Node()
{
    mData = 0;
    mLeft = NULL;
    mRight = NULL;
}

template <typename T>
BST_Node<T>::BST_Node(T data)
{
    mData = data;
    mLeft = NULL;
    mRight = NULL;
}

template <typename T>
BST_Node<T>::BST_Node(T data, BST_Node<T> *left, BST_Node<T> *right)
{
    mData = data;
    mLeft = left;
    mRight = right;
}

template <typename T>
BST<T>::BST()
{
    mRootNode = NULL;
}

template <typename T>
BST<T>::BST(T data, BST_Node<T> *left, BST_Node<T> *right)
{
    mRootNode->mLeft = left;
    mRootNode->mRight = right;
    mRootNode->mData = data;
}

模板
结构BST_节点
{
T-mData；
BST_节点*mLeft，*mRight；
BST_节点（）；
BST_节点（T数据）；
BST_节点（T数据，BST_节点*左，BST_节点*右）；
};
模板
BST_节点：：BST_节点（）
{
mData=0；
mLeft=NULL；
mRight=NULL；
}
模板
BST_节点：：BST_节点（T数据）
{
mData=数据；
mLeft=NULL；
mRight=NULL；
}
模板
BST_节点：：BST_节点（T数据，BST_节点*左，BST_节点*右）
{
mData=数据；
mLeft=左；
mRight=右；
}

BST构造函数：

template <typename T>
struct BST_Node
{
    T           mData;
    BST_Node<T> *mLeft, *mRight;

    BST_Node();
    BST_Node(T data);
    BST_Node(T data, BST_Node<T> *left, BST_Node<T> *right);
};

template <typename T>
BST_Node<T>::BST_Node()
{
    mData = 0;
    mLeft = NULL;
    mRight = NULL;
}

template <typename T>
BST_Node<T>::BST_Node(T data)
{
    mData = data;
    mLeft = NULL;
    mRight = NULL;
}

template <typename T>
BST_Node<T>::BST_Node(T data, BST_Node<T> *left, BST_Node<T> *right)
{
    mData = data;
    mLeft = left;
    mRight = right;
}

template <typename T>
BST<T>::BST()
{
    mRootNode = NULL;
}

template <typename T>
BST<T>::BST(T data, BST_Node<T> *left, BST_Node<T> *right)
{
    mRootNode->mLeft = left;
    mRootNode->mRight = right;
    mRootNode->mData = data;
}

模板
BST:：BST（）
{
mRootNode=NULL；
}
模板
BST:：BST（T数据，BST_节点*左，BST_节点*右）
{
mRootNode->mLeft=左侧；
mRootNode->mRight=右侧；
mRootNode->mData=数据；
}

问题可能是因为树不平衡。这意味着在最坏的情况下，调用堆栈将包含与树中项目数相同的函数调用数。每次插入后，您应该检查树的平衡，以及是否需要更正

此外，您还可以在以下位置拆分插入函数：

查找将成为父节点的节点

添加新节点

---

然后优化查找功能（只需谷歌搜索“最左侧”/“最右侧”）.

构造函数的代码是什么？堆栈溢出最终肯定会发生。@NicolasChabanovsky是非常正确的：重新平衡树将有助于避免问题并最大限度地利用堆栈，直到达到一定的限制。但是，超过该阈值时，堆栈将再次变得不足。在某些系统上，使用gcc作为编译器，您可以可能会使用拆分堆栈选项再次提高阈值。我真的希望我能这样做。这个项目的整个要点是比较二叉搜索树和AVL树，所以我实际上不应该平衡BST。我理解这个问题，这意味着你说没有办法解决这个问题？