链表连续偶数组反转功能异常：偶节点丢失问题求助

核心问题：未更新链表头节点 #

你的程序出现节点丢失的直接原因是：反转函数返回的新头节点没有被同步到链表类的head成员中。当处理第一个连续偶数组（2、18、24）时，reverse_Groups已经将这组节点反转为24→18→2，并返回24作为新的头节点，但你在main中只是调用了函数，没有将返回值赋值给链表的head，导致打印时仍然从原头节点2开始，而2的next已经被设置为3，因此24和18就从链表的遍历路径中消失了。

修复步骤 #

1. 添加头节点更新方法

在linked_list类的public部分添加setHead方法，用于更新链表的头节点：

void setHead(node* newHead) {
    head = newHead;
}

2. 同步反转后的新头节点

在main函数中接收reverse_Groups的返回值，并调用setHead更新链表头：

node* newHead = a.reverse_Groups(a.getHead(), NULL);
a.setHead(newHead);

3. 修复双向链表的prev指针（隐藏问题）

你的链表定义了双向指针（prev），但反转函数只处理了next指针，这会导致双向链表结构不一致，后续使用prev操作会出错。需要修改reverse_Groups中的循环逻辑，同步更新prev指针：

node* reverse_Groups(node* head, node* prev) {
    if (head == NULL) {
        return NULL;
    }

    node *tmp;
    node *curr;
    curr = head;

    while (curr != NULL && curr->data % 2 == 0) {
        tmp = curr->next;
        curr->next = prev;
        // 同步更新prev指针
        if (prev != NULL) {
            prev->prev = curr;
        }
        prev = curr;
        curr = tmp;
    }

    if (curr != head) {
        head->next = curr;
        // 设置下一个节点的prev指向当前组的尾节点（原head）
        if (curr != NULL) {
            curr->prev = head;
        }
        curr = reverse_Groups(curr, NULL);
        return prev;
    } else {
        head->next = reverse_Groups(head->next, head);
        // 同步更新下一个节点的prev
        if (head->next != NULL) {
            head->next->prev = head;
        }
        return head;
    }
}

4. 移除冗余的curr成员

struct node中的curr成员是多余的无效变量，直接删除即可：

struct node {
    int data;
    node *next;
    node *prev;
};

修正后的完整代码 #

#include <iostream>
using namespace std;

struct node {
    int data;
    node *next;
    node *prev;
};

class linked_list {
private:
    node *head,*tail;
public:
    linked_list() {
        head = NULL;
        tail = NULL;
    }

    void add_node(int n) {
        node *tmp = new node;
        tmp->data = n;
        tmp->next = NULL;
        tmp->prev = NULL; // 初始化prev为NULL

        if(head == NULL) {
            head = tmp;
            tail = tmp;
        } else {
            tail->next = tmp;
            tmp->prev = tail;
            tail = tail->next;
        }
    }

    node* getHead() {
        return head;
    }

    void setHead(node* newHead) {
        head = newHead;
    }

    void print_List() {
        node *tmp;
        tmp = head;
        while (tmp != NULL) {
            cout << tmp->data << " ";
            tmp = tmp->next;
        }
    }

    node* reverse_Groups(node* head, node* prev) {
        if (head == NULL) {
            return NULL;
        }

        node *tmp;
        node *curr;
        curr = head;

        while (curr != NULL && curr->data % 2 == 0) {
            tmp = curr->next;
            curr->next = prev;
            if (prev != NULL) {
                prev->prev = curr;
            }
            prev = curr;
            curr = tmp;
        }

        if (curr != head) {
            head->next = curr;
            if (curr != NULL) {
                curr->prev = head;
            }
            curr = reverse_Groups(curr, NULL);
            return prev;
        } else {
            head->next = reverse_Groups(head->next, head);
            if (head->next != NULL) {
                head->next->prev = head;
            }
            return head;
        }
    } 
};

int main() {
    linked_list a;
    int numNodes, i, tempNode;
    
    cin >> numNodes;
    
    for (i = 0; i < numNodes; ++i) {
        cin >> tempNode;
        a.add_node(tempNode);
    }
    
    node* newHead = a.reverse_Groups(a.getHead(), NULL);
    a.setHead(newHead);
    a.print_List();

    return 0;
}

测试验证 #

输入测试用例：9 2 18 24 3 5 7 9 6 12（先输入节点数9），程序将输出预期结果：24 18 2 3 5 7 9 12 6。

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