单数链表在传递给函数时变为循环列表 我试图用C++反转链表，然后打印出反转列表。

例如： 原始列表为1->2->3 回归后：3->2->1

但是当我试图打印出反向链表时，3->2->1变成了一个循环链表，就像32

以下是我的代码：

#include <iostream>
#include <sstream>
using namespace std;
class List{
public:
    int value;
    List *next;
    List(int);
    List(int, List *);
};

List::List(int v){
    value = v;
    next = NULL;
}

List::List(int v, List *ne){
    value = v;
    next = ne;
}

string IntToString(int val){
    stringstream temp;
    temp<<val;
    return temp.str();
}

void print(List *l){
    string output= "";
    while(l->next != NULL){
        output+=(IntToString(l->value)+"-->");
        l = l->next;
    }
    output+=(IntToString(l->value)+"-->NULL");
    cout<<output<<endl;
}

List reverse(List L){
    if(L.next == NULL) return L;
    List remain = reverse(*(L.next));
    List *current = &remain;
    while(current->next != NULL)
        current = (current->next);
    L.next = NULL;
    current->next = &L;
    //print(remain);
    return remain;
}

List copy(List l){
    return l;
}

int main() {
    List L3(3);
    List L2(2, &L3);
    List L1(1, &L2);
    List L4 = reverse(L1);
    print(&L4);
    return 0;
}

#包括
#包括
使用名称空间std；
班级名单{
公众：
int值；
列表*下一步；
名单（国际）；
列表（int，List*）；
};
列表：：列表（intv）{
值=v；
next=NULL；
}
列表：：列表（int v，List*ne）{
值=v；
next=ne；
}
字符串IntToString（int val）{
串流温度；
tempvalue）+“--->”）；
l=l->next；
}
输出+=（IntToString（l->value）+“-->NULL”）；
cout我认为您的反向算法是正确的，但是
remain
是一个局部变量，返回后无效，因此L4将包含无效指针。将
reverse（）
的签名更改为获取并返回
List*

List *reverse(List *L){
    if(L->next == NULL) return L;
    List *remain = reverse(L->next);
    List *current = remain;
    while(current->next != NULL)
        current = (current->next);
    L->next = NULL;
    current->next = L;
    //print(remain);
    return remain;
}
列表*反向（列表*L）{
如果（L->next==NULL）返回L；
列表*保持=反向（L->next）；
列表*当前=保留；
while（当前->下一步！=NULL）
当前=（当前->下一步）；
L->next=NULL；
当前->下一步=L；
//打印（保留）；
返回剩余；
}
只需查看
reverse（）
函数，即可在堆栈上创建一个名为
remaine
的对象，并将其插入列表中。这无法工作：一旦您从函数返回，此对象将超出范围（
main（）
中的原始对象也有相同的问题，但您在离开
main（）
后不会尝试使用它们）。此外，您的
reverse（）
函数似乎具有二次性能，而它应该是线性的。我认为像这样的事情会起作用：

List* reverse(List* head) {
    List* tail(0);
    while (head) {
        List* tmp(head);
        head = head->next;
        tmp->next = tail;
        tail = tmp;
    }
    return tail;
}

上述实现也避免了递归。
首先，我想指出，包含指向另一个列表的指针的
列表
在概念上是错误的

单独创建一个列表节点类，例如

struct ListNode {
    int value;
    Node *next;
};

然后，您的
列表变为

class List {
    ...
    ListNode *head;
    ...
};

现在开始倒车。在方法
List reverse（List L）
中，L只是一个局部变量。之后就超出了范围,

因此，从逻辑上讲，返回一个
列表
，该列表的
下一个
值为L的位置是不正确的

current->next = &L;
return remain; // remain is equal to *current and current->next = &L

这会导致实现中出现未定义的行为

编辑：我有一些空闲时间，所以我想出了一个办法。它使用相同的算法，尽管修改了调用它的原始列表

current->next = &L;
return remain; // remain is equal to *current and current->next = &L