Почему удаляются только те чётные элементы которые я добавил, а не все которые есть в бинарном дереве? - C++ - Ответ 14966637

#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <ctime>
#include <stack>
 
using namespace std;
 
int tabs = 0;
struct Node;
Node* Root = 0;
 
struct Node
{
    int Data{};
    Node* Left{};
    Node* Right{};
};
 
Node* Add(int aData, Node*& aNode)
{
    Node* pRet = 0;
    if (!aNode)
    {
        aNode = new Node;
        aNode->Data = aData;
        aNode->Left = 0;
        aNode->Right = 0;
        pRet = aNode;
        return pRet;
    }
    else
    {
        if (aNode->Data > aData)
        {
            pRet = Add(aData, aNode->Left);
        }
        else
        {
            pRet = Add(aData, aNode->Right);
        }
    }
    return pRet;
}
 
void print(Node* aNode)
{
    if (!aNode) return;
    tabs += 5;
    print(aNode->Left);
    for (int i = 0; i < tabs; i++)
    {
        cout << " ";
    }
    cout << aNode->Data << endl;
    print(aNode->Right);
    tabs -= 5;
    return;
}
 
void pr_obh(Node* aNode)
{
    std::stack<Node*> stk;
    stk.push(aNode);
    while (true)
    {
        while (true)
        {
            Node* pTop = stk.top();
            if (!pTop)
            {
                stk.pop();
                break;
            }
            if (pTop->Left)
            {
                stk.push(pTop->Left);
            }
            else
            {
                break;
            }
        }
        if (stk.empty())
        {
            break;
        }
        Node* pTop = stk.top();
        stk.pop();
        if (!pTop)
        {
            break;
        }
        std::cout << pTop->Data << std::endl;
        stk.push(pTop->Right);
    }
}
 
Node* findEven(Node* aNode)
{
    Node* pRet = 0;
    std::stack<Node*> stk;
    stk.push(aNode);
    while (true)
    {
        while (true)
        {
            Node* pTop = stk.top();
            if (!pTop)
            {
                stk.pop();
                break;
            }
            if (pTop->Left)
            {
                stk.push(pTop->Left);
            }
            else
            {
                break;
            }
        }
        if (stk.empty())
        {
            break;
        }
        Node* pTop = stk.top();
        stk.pop();
        if (!pTop)
        {
            break;
        }
        if (pTop->Data % 2 == 0)
        {
            pRet = pTop;
            break;
        }
        stk.push(pTop->Right);
    }
    return pRet;
}
 
Node* findParent(Node* aNode, Node* pChild)
{
    Node* pRet = 0;
    if (pChild)
    {
        std::stack<Node*> stk;
        stk.push(aNode);
        while (true)
        {
            while (true)
            {
                Node* pTop = stk.top();
                if (!pTop)
                {
                    stk.pop();
                    break;
                }
                if (pTop->Left)
                {
                    stk.push(pTop->Left);
                }
                else
                {
                    break;
                }
            }
            if (stk.empty())
            {
                break;
            }
            Node* pTop = stk.top();
            stk.pop();
            if (!pTop)
            {
                break;
            }
            if (pTop->Left == pChild || pTop->Right == pChild)
            {
                pRet = pTop;
                break;
            }
            stk.push(pTop->Right);
        }
    }
 
    return pRet;
}
 
void DelNode(Node* pDel)
{
    Node* pParent = findParent(Root, pDel);
    if (!pDel->Left && !pDel->Right)
    {
        if (pParent)
        {
            if (pDel == pParent->Left)
            {
                pParent->Left = 0;
            }
            else
            {
                pParent->Right = 0;
            }
        }
        else
        {
            Root = 0;
        }
        delete pDel;
        pDel = 0;
    }
    else if (pDel->Left && !pDel->Right)
    {
        if (pParent->Left == pDel)
        {
            pParent->Left = pDel->Left;
        }
        else
        {
            pParent->Right = pDel->Left;
        }
        delete pDel;
        pDel = 0;
    }
    else if (pDel->Right && !pDel->Left)
    {
        if (pParent->Left == pDel)
        {
            pParent->Left = pDel->Right;
        }
        else
        {
            pParent->Right = pDel->Right;
        }
        delete pDel;
        pDel = 0;
    }
    else if (pDel->Right && pDel->Left)
    {
        Node* pTmp = pDel->Left;
        while (pTmp->Right)
        {
            pTmp = pTmp->Right;
        }
        std::swap(pTmp->Data, pDel->Data);
        
        Node* pTmpParent = findParent(Root, pTmp);
        if (pTmpParent->Left == pTmp)
        {
            pTmpParent->Left = pTmp->Left;
        }
        else
        {
            pTmpParent->Right = pTmp->Left;
        }
        delete pTmp;
        pTmp = 0;
    }
}
 
void Delete_tree(Node*& aNode)
{
    if (!aNode) return;
    Delete_tree(aNode->Left);
    Delete_tree(aNode->Right);
    delete aNode;
    return;
}
 
 
int main()
{
    int N;
    int element;
    setlocale(0, "rus");
    srand((unsigned)time(0));
    cout << "Введите количество элементов будующего дерева: ";
    cin >> N;
    for (int i = 0; i < N; i++)
    {
        int num = rand() % 100;
        Add(num, Root);
    }
    cout << "Вывод дерева: " << endl;
    print(Root);
    cout << endl;
 
    cout << "Удаление чётных элементов" << endl;
    Node* pEven = 0;
    while ((pEven = findEven(Root)) != 0)
    {
        DelNode(pEven);
    }
 
    cout << "Вывод дерева: " << endl;
    print(Root);
    cout << endl;
 
    cout << "Добавление новых элементов : Введите количество элементов: " << endl;
    cin >> N;
    for (int i = 0; i < N; i++)
    {
        int num = rand() % 100;
        Add(num, Root);
    }
 
    cout << "Вывод дерева: " << endl;
    print(Root);
    cout << endl;
 
    Delete_tree(Root);
    cout << "Вся динамическая память очищена";
 
}