Question

我试图反转链表，但每当我执行以下功能时，我只得到最后一个元素。例如，如果列表包含之前的11,12,13。执行该函数后，它只包含13.请指出我的代码中的错误

void reverselist() {
    struct node *a, *b, *c;
    a = NULL;
    b = c = start;

    while (c != NULL) {
        c = b->next;
        b->next = a;
        a = b;
        b = c;
    }
    start = c;
}

Answer 1

你的循环保护不确保start为null吗？
如果您没有使用start来识别列表的第一个元素，那么您正在使用的变量仍然指向第一个元素，即现在最后一个元素。

Answer 2

我会做一个prepend函数，并完成以下操作：

struct node* prepend(struct node* root, int value)
{
    struct node* new_root = malloc(sizeof(struct node));
    new_root->next = root;
    return new_root;
}

struct node* reverselist(struct node* inlist)
{
    struct node* outlist = NULL;

    while(inlist != NULL) {
        struct node* new_root = prepend(outlist, inlist->value);
        outlist = new_root;
        inlist = inlist->next;
    }

    return outlist;
}

没有对此进行过测试，但猜猜你已经掌握了它的想法。可能只是你的变量名，它没有描述任何东西，但我认为这种方法更清晰，更容易理解实际发生的事情。

编辑：

有一个问题我为什么不在这里做，所以我会在这里回答：

你能在原地进行吗？你确定你不想保留原始清单？
你需要在现场进行吗？ malloc是否耗时/这是您的代码性能关键部分？记住：过早优化是万恶之源。

事情是，这是第一个实现。它应该工作，而不是优化。它还应该在实现这个实现之前编写一个测试，并且你应该保持这个缓慢，未优化的实现，直到测试通过，并且你已经证明它会减慢你的使用！

如果你有一个通过单元测试，并证明实现要慢，你应该优化代码，并确保它仍然通过测试，而不改变测试。

此外，是否有必要进行现场操作？如何在还原之前分配内存，这样你只需要一次分配调用，并且希望能够提升性能。

这样每个人都很开心，你有一个更干净的代码，并避免让鲍勃叔叔带着霰弹枪出现在门口。

Answer 3


// You should assume that Node has a Node* called next that
// points to the next item in a list
// Returns the head of the reversed list if successful, else NULL / 0
Node *reverse( Node *head )
{
    Node *prev = NULL;

    while( head != NULL )
    {
        // Save next since we will destroy it
        Node *next = head->next;

        // next and previous are now reversed
        head->next = prev;

        // Advance through the list
        prev = head;
        head = next;
    }
    return previous;
}

Answer 4

c是辅助指针。

void reverselist()
{
    struct node *a, *b, *c;
    a=NULL;
    b=start;
    while(b!=NULL)
    {
        c=b->next
        b->next=a;
        a=b
        b=c
    }
    start=a;
}

无法撤消链接列表

4 个答案: