Pętla wykonuje się wiecznie: niepoprawny warunek?

Mógłby ktoś pomóc zdebugować mi ten okrojony kod?

Funkcja wewnetrzna się blokuje na ostatniej iteracji pętli while - przynajmniej do takiego wniosku doszedłem, mogę się mylić. Być może nie, bo program po 2 sekundach od wystąpienia błędu się kończy, a w nieskończonej pętli while chyba by szedł w nieskończoność.

Problem występuje wtedy, gdy w strukturze Node już nie mam żadnych elementów (wszystko pojedynczo usunąłem).

#include <iostream>
#include <algorithm>

struct Node {
    Node *pNextNode;
    int data;
};

struct Target {
    Target *pNextTarget;
    int data;
};

void AddNode(Node *&pHead, const int &data)
{
    pHead = new Node {pHead, data};
}

void AddTarget(Target *&pHead, const int &data)
{
    pHead = new Target {pHead, data};
}

// usuwa pierwszy Node
void DeleteFirstNode(Node *&pHead)
{
    Node *NodeToBeDeleted;

    if (pHead == nullptr)
        std::cout << "List is already empty.";
    else
    {
        NodeToBeDeleted = pHead;
        pHead = pHead->pNextNode;

        delete NodeToBeDeleted;

        std::cout << "DELETED FROM NODE\n";
    }
}

void Wewnetrzna(Node *&pHeadNode, Target *&pHeadTarget)
{
    while ((pHeadNode->data == pHeadTarget->data)) {

        std::cout << "\n*****To sie musi wykonac*****\n" << std::endl;
        DeleteFirstNode(pHeadNode);

        std::cout << "\n TUTAJ SIE BLOKUJE \n";
        std::cout << "\npHeadNode = " << pHeadNode << std::endl;
        if (pHeadNode==nullptr)
            std::cout << "\nUpewniam sie: pHeadNode = " << pHeadNode << std::endl;
    }
    std::cout << "To sie nie wykona\n";
}

void Zewnetrzna( Node *&pHeadNode, Target *&pHeadTarget)
{
    while (pHeadTarget) {
        if (pHeadTarget==nullptr){
            std::cout << "To tez sie nie wykona\n";
            return;
            }
        Wewnetrzna(pHeadNode, pHeadTarget);
        pHeadTarget=pHeadTarget->pNextTarget;
    }
}

int main()
{
    Node *ptrNode = nullptr;
    AddNode(ptrNode, 5);
    AddNode(ptrNode, 7);
    AddNode(ptrNode, 16);
    AddNode(ptrNode, 16);
    AddNode(ptrNode, 25);


    Target *ptrTarget = nullptr;
    AddTarget(ptrTarget, 5);
    AddTarget(ptrTarget, 7);
    AddTarget(ptrTarget, 16);
    AddTarget(ptrTarget, 25);

    Zewnetrzna(ptrNode, ptrTarget);
    std::cout << "To sie powinno wykonac" << std::endl;
    std::cin.get();
    return 0;
}

Efekt:

Na samym końcu się coś blokuje i program na ~2 sekundy się zatrzymuje po czym się kończy. Mimo wszystko kod w tych funkcjach wykonuje się dobrze, robi to co ma robić, tylko chciałbym się pozbyć tej 2 sekundowej blokady - ewidentnie coś mam źle napisane.

Próbowałem m.in. w wewnetrzna dopisać dodatkowy warunek do pętli while:

while ((pHeadNode->data == pHeadTarget->data)||(pHeadNode != nullptr))

Jednak nic to nie pomogło.
Jedyne co pomogło to:

while ((pHeadNode->data == pHeadTarget->data)&&(pHeadNode == nullptr))

ale wtedy zawartość pętli np.:

std::cout << "\n*****To sie musi wykonac*****\n" << std::endl;

nie wykona się ani razu.

W Wewnetrzna nie inkrementujesz wskaźnika, usuwanie działa poprawnie?

@lion137: tak, testowałem - usuwanie działa dobrze.
Wskaźnik jest inkrementowany podczas usuwania.

jaka instrukcja sie wykona po std::cout << "\nUpewniam sie: pHeadNode = " << pHeadNode << std::endl;? jakigo wyniku po niej oczekujesz?

W gruncie rzeczy po niej oczekuję wyjście z pętli, następnie wyjście z wewnetrzna, i poźniej wyjście z zewnetrzna tak, żeby mogło się dalej wykonywać to co mam w main() - w tym wypadku:
std::cout << "To sie powinno wykonac" << std::endl;

Problem rozwiązany

if (pHeadNode==nullptr)
            return;

Dodałem to do while w wewnetrzna. (xD) Wcześniej próbowałem to robić, ale sprawdzałem ten warunek w pętli while tuż na początku zamiast na końcu tj. przed usuwaniem elementów listy.