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

#include<iostream>
#include<cstdlib>
 
using namespace std;
 
int tabs = 0;
 
struct Node
{
    int Data;
    Node* Left;
    Node* Right;
};
 
void Add(int aData, Node*& aNode)
{
    if(!aNode)
    {
        aNode = new Node;
        aNode->Data = aData;
        aNode->Left = 0;
        aNode->Right = 0;
        return;
    }
    else
    {
        if(aNode->Data > aData)
        {
            Add(aData, aNode->Left);
        }
        else
        {
            Add(aData, aNode->Right);
        }
    }
}
 
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)
{
    if(aNode == NULL) return;
    pr_obh(aNode->Left);
    cout<<aNode->Data<<endl;
    pr_obh(aNode->Right);
}
 
void obr_obh(Node*& aNode)
{
    if(aNode == NULL) return;
    obr_obh(aNode->Right);
    cout <<aNode->Data<<endl;
    obr_obh(aNode->Left);
}
 
void add_elem(int aData, Node*& aNode)
{
    if(!aNode)
    {
        aNode = new Node;
        aNode->Data = aData;
        aNode->Left = 0;
        aNode->Right = 0;
        return;
    }
    else
    {
        if(aData < aNode->Data)
        {
            add_elem(aData, aNode->Left);
        }
        else if(aData > aNode->Data)
        {
            add_elem(aData, aNode->Right);
        }
    }
}
 
Node* delete_elem(int aData, Node*& aNode)
{
    if(aNode == NULL)
        return aNode;
        
    if(aNode->Data == aData)
    {
        Node* temp;
        if(aNode->Right == NULL)
        {
            temp = aNode->Left;
        }
        else
        {
            Node* temp2 = aNode->Right;
            
            if(aNode->Left == NULL)
            {
                temp2->Left = aNode->Left;
                temp = temp2;
            }
            else
            {
                Node* temp3 = temp2->Left;
                while(temp3->Left != NULL)
                {
                    temp2 = temp3;
                    temp3 = temp2->Left;
                }
                temp2->Left = temp3->Right;
                temp3->Left = aNode->Left;
                temp3->Right = aNode->Right;
            }
        }
        delete aNode;
        return temp;
    }
    else if(aData < aNode->Data)
    {
        aNode->Left = delete_elem(aData, aNode->Left);
    }
    else
    {
        aNode->Right = delete_elem(aData, aNode->Right);
    }
    return aNode;
}
 
void Delete_tree(Node*& aNode)
{
    if(!aNode) return;
    Delete_tree(aNode->Left);
    Delete_tree(aNode->Right);
    delete aNode;
    return;
}
 
int main()
{
    Node* Root = 0;
    int N;
    int element;
    setlocale(0, "rus");
    cout <<"Введите количество элементов будующего дерева: ";
    cin >> N;
    for(int i = 0; i < N; i++)
    {
        Add(rand() % 100, Root);
    }
    cout <<"Вывод дерева: "<<endl;
    print(Root);
    cout << endl;
    
    cout <<"Прямой обход: "<<endl;
    pr_obh(Root);
    cout << endl;
    
    cout <<"Обратный обход: "<<endl;
    obr_obh(Root);
    cout << endl;
    
    cout <<"Добавление нового элемента"<<endl;
    cout <<"Введите элемент: ";
    cin >> element;
    add_elem(element, Root);
    
    cout <<"Вывод дерева: "<<endl;
    print(Root);
    cout << endl;
    
    cout <<"Удаление чётных элементов"<<endl;
    for(int i = 0; i < N; i++)
    {
        if (element % 2 == 0)
        {
            delete_elem(element, Root);
        }
    }
    
    cout <<"Вывод дерева: "<<endl;
    print(Root);
    cout << endl;
    
    Delete_tree(Root);
    cout <<"Вся динамическая память очищена";
    
    return 0;
}

Node* Del_Info(Node*& aNode, int aData)
{
    Node *Del, *Prev_Del, *R, *Prev_R;
    Del = aNode;
    Prev_Del = NULL;
    
    while(Del != NULL && Del -> Data != aData)
    {
        Prev_Del = Del;
        if(Del->Data > aData)
        {
            Del = Del->Left;
        }
        else
        {
            Del = Del->Right;
        }
    }
    if(Del == NULL)
    {
        cout <<"Элемент не найден" << endl;
        return aNode;
    }
    
    if(Del -> Right == NULL)
    {
        R = Del->Left;
    }
    
    else
    {
        if(Del -> Left == NULL)
        {
            R = Del->Right;
        }
        else
        {
            Prev_R = Del;
            R = Del->Left;
            while (R->Right != NULL)
            {
                Prev_R = R;
                R = R->Right;
            }
            
            if(Prev_R == Del)
            {
                R->Right = Del->Right;
            }
            else
            {
                R->Right = Del->Right;
                Prev_R->Right = R->Left;
                R->Left = Prev_R;
            }
        }
        if(Del == aNode)
        {
            aNode = R;
        }
        else
        {
            if(Del->Data < Prev_Del->Data)
            {
                Prev_Del->Left = R;
            }
            else
            {
                Prev_Del->Right = R;
                delete Del;
                return aNode;
            }
        }
    }
}

#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 << "Вся динамическая память очищена";
 
}