使用迭代方法反转链接列表

Question

我的反转链表的代码有什么问题？

void rev(node* &head)
{
    int flag=0;
    node* head1=NULL;
    while(head->next!=NULL)
    {
        node* temp1=head;
        node* temp2=head;
        while(temp1->next!=NULL)
        {
            temp2=temp1;
            temp1=temp1->next;
        }
        if(flag==0)
        {
            head1=temp1;
            flag++;
        }
        temp1->next=temp2;
        temp2->next=NULL;
    }
    head=head1;
    delete head1;
}

我试图解决反转链接列表的标准问题。 所以我尝试实施这种方法，但它似乎进入了无限循环，我无法理解为什么。

Answer 1

您的 function 无效。

例如，传递的指针head可以等于nullptr 。 在这种情况下，这个 while 循环

while(head->next!=NULL)

已经可以调用未定义的行为。

或者列表中没有要删除的内容但是 function 有这些语句

head=head1;
delete head1;

那没有意义。

即使通过调用 delete 删除语句，这也不会使 function 正确。 例如，如果列表只包含一个节点，那么这个 while 循环

while(head->next!=NULL)

不会被执行。 结果，由于循环后的这条语句，指针head将设置为NULL

head=head1;

因为在循环之前指针head1被设置为NULL

node* head1=NULL;

也似乎在这个嵌套的 while 循环中

while(temp1->next!=NULL)
{
    temp2=temp1;
    temp1=temp1->next;
}

您正试图在列表中找到至少效率低下的最后一个节点。

而你的function不清楚，太复杂了。

要编写 function，学习 header <functional>中声明的标准 C++ function std::exchange就足够了，这将使 function 的代码更加简单明了。

下面是一个演示程序，展示了如何实现 function 反转单链表。

#include <iostream>
#include <functional>
#include <iterator>

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

void clear( node * &head )
{
    while ( head ) delete std::exchange( head, head->next );
}

void assign( node * &head, const int a[], size_t n )
{
    clear( head );

    for (node **current = &head; n--; current = &( *current )->next)
    {
        *current = new node{ *a++, nullptr };
    }
}

std::ostream & display( const node *const &head, std::ostream &os = std::cout )
{
    for (const node *current = head; current != nullptr; current = current->next)
    {
        os << current->data << " -> ";
    }

    return os << "null";
}

void reverse( node * &head )
{
    for ( node *current = head, *previous = nullptr; current != nullptr; previous = head )
    {
        head = std::exchange( current, current->next );
        head->next = previous;
    }
}

int main()
{
    node *head = nullptr;
    const int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    assign( head, a, std::size( a ) );

    display( head ) << '\n';

    reverse( head );

    display( head ) << '\n';

    clear( head );
}

程序 output 是

0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> null
9 -> 8 -> 7 -> 6 -> 5 -> 4 -> 3 -> 2 -> 1 -> 0 -> null

可以看到function只有一个for循环，其复合语句只包含两条语句

void reverse( node * &head )
{
    for ( node *current = head, *previous = nullptr; current != nullptr; previous = head )
    {
        head = std::exchange( current, current->next );
        head->next = previous;
    }
}

如果不使用标准 function std::exchange ，则反转列表的 function 将多一个语句，例如

void reverse( node * &head )
{
    for ( node *current = head, *previous = nullptr; current != nullptr; previous = head )
    {
        head = current;
        current = current->next; 
        head->next = previous;
    }
}

Answer 2

首先，一个迷你代码审查：

//
// Bigger issues implied by this function are that it is not a very good
// linked list, likely an extremely basic C-style list. However, that is
// beyond the scope of this question.
//
void rev(node* &head)
{
    int flag=0;  // Unnecessary
    node* head1=NULL;  // Prefer nullptr
    while(head->next!=NULL)
    {
        node* temp1=head;
        node* temp2=head;  // Choose better names
        while(temp1->next!=NULL)  // Traverse the entire list at every iteration
        {
            temp2=temp1;
            temp1=temp1->next;
        }
        if(flag==0)
        {
            head1=temp1;
            flag++;
        }
        temp1->next=temp2;  // Always and only swaps the last two elements
        temp2->next=NULL;

        // Never updates head in the loop; loop is infinite
    }
    head=head1;
    delete head1;  // head1 was pointing to a valid node; you just nuked your
                   // entire list
}

该算法非常简单，当用纸和铅笔画出问题时，它就会自动显示出来。 你只需要让箭头指向另一个方向，然后重新分配头部。 您正在尝试这样做，但除了最后两个节点外，您没有更改任何指针。 您需要在列表中移动时更改它们。

不需要特殊的head检查和flag 。 您自然会到达尾部，并且可以在这样做时重新分配头部。

这是重新设计的算法：

#include <iostream>

struct node {
  int data;
  node* next;

  node(int d) : data(d), next(nullptr) {}
};

//
// Bigger issues implied by this function is that it is not a very good
// linked list, likely an extremely basic C-style list. However, that is
// beyond the scope of this question.
//
void rev(node*& head) {
  node* prev = nullptr;
  node* curr = head;
  node* next = nullptr;  // Not immediately assigned to account for
                         // empty list.

  while (curr) {
    next = curr->next;  //
    curr->next = prev;  // This order of operations is very important
    prev = curr;        //
    curr = next;        //
  }

  head = prev;
}

int main() {
  node* list = new node{1};
  list->next = new node{2};
  list->next->next = new node{3};
  list->next->next->next = new node{4};
  list->next->next->next->next = new node{5};

  node* walker = list;
  std::cout << "Original list: ";
  while (walker != nullptr) {
    std::cout << walker->data << ' ';
    walker = walker->next;
  }
  std::cout << '\n';

  rev(list);
  std::cout << "Reversed list: ";
  walker = list;
  while (walker != nullptr) {
    std::cout << walker->data << ' ';
    walker = walker->next;
  }
  std::cout << '\n';

  // On the one hand, I don't delete my nodes. On the other,
  // the program is ending and the OS will clean up my mess.
  // This is generally a bad practice.
}

Output：

❯ ./a.out
Original list: 1 2 3 4 5 
Reversed list: 5 4 3 2 1 

虽然它需要更多代码，但强烈建议使用正确的 C++ 链表 class 以避免main()中所需的彻头彻尾的愚蠢初始化。

而且我知道这段代码很可能只是为了理解这个特定的算法，但是 C++ 标准库确实提供了单链表和双向链表，这两种链表都很容易逆向。