双向链表pushBack函数异常：新节点替换首节点并自指向致死循环

Hey Dave, let's break down the issues you're hitting with your doubly linked list's pushBack method. The behavior you described—overwriting the head node, the new node's prev and next pointing to itself, and the infinite print loop—are classic signs of pointer mismanagement or scope mistakes. Let's walk through the most likely culprits and fix them.

Common Causes & Fixes #

1. Local Node Scope (Stack Allocation Instead of Heap) #

If you're creating the new node on the stack inside pushBack (like Node newNode;), the node gets destroyed as soon as the function exits. This leaves you with dangling pointers that point to deallocated memory, leading to unpredictable behavior (like the node appearing to point to itself or overwriting the head).

Fix: Always allocate nodes on the heap using new (or malloc in C) so they persist outside the function's scope. For example:

Node* newNode = new Node(value); // C++
// Or for C: Node* newNode = (Node*)malloc(sizeof(Node));

2. Incorrect Handling of Empty Lists #

When the list is empty, you need to set both head and tail to the new node. If you only update head and leave tail uninitialized, or accidentally set the new node's prev/next to itself instead of nullptr, you'll end up with the broken state you're seeing.

Fix: For an empty list:

if (head == nullptr) {
    head = newNode;
    tail = newNode;
    newNode->prev = nullptr;
    newNode->next = nullptr;
}

3. Missing Tail Pointer Updates for Non-Empty Lists #

If you're not properly linking the existing tail to the new node, or forgetting to update the tail pointer to point to the new node, you might accidentally overwrite the head instead. This usually happens if you mix up head and tail in your assignments.

Fix: For non-empty lists, link the old tail to the new node, then update the tail:

else {
    tail->next = newNode;
    newNode->prev = tail;
    newNode->next = nullptr; // Critical to avoid infinite loops
    tail = newNode;
}

Corrected pushBack Example #

Here's a full, corrected implementation snippet to reference:

// Node structure definition
struct Node {
    int data;
    Node* prev;
    Node* next;
    // Constructor for easy initialization (C++)
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};

class DoublyLinkedList {
private:
    Node* head;
    Node* tail;
public:
    DoublyLinkedList() : head(nullptr), tail(nullptr) {}

    void pushBack(int val) {
        Node* newNode = new Node(val);

        // Empty list case
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } 
        // Non-empty list case
        else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
            // newNode->next is already nullptr from the constructor
        }
    }

    // Safe print function to avoid infinite loops
    void printList() {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << "\n";
    }
};

Key Checks to Verify #

• Double-check that you never assign head = newNode when adding to the tail (that's exactly what's causing your head node to be replaced).
• Ensure every new node's next is set to nullptr when added to the tail—this stops the print loop from running forever.
• Confirm you're not using stack-allocated nodes (they die when the function ends, causing dangling pointers).

内容的提问来源于stack exchange，提问作者Dave