Question

I’m trying to reverse a linked list by using C++ and then print out the reversed one.

For example:
the original list is 1->2->3
after reversion: 3->2->1

But when I tried to print out the reversed linked list, 3->2->1 became a circular linked list like 3<->2

Followings are my codes:

#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;
}

Can anyone tell me why this happens? Thanks a lot!

Answer 1

First of all, I want to point out to you that a list containing a pointer to another list is conceptually wrong.

Create a list node class seperately, e.g.

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

Then your List becomes,

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

Now onto reversing. In the method List reverse( List L ), L is simply a local variable. It goes out of scope after,

    return remain;
} // Here the scope of L ends

So it is logically incorrect to return a List whose next value is location of L,

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

This causes undefined behavior in your implementation.

EDIT: I have some free time, so I came up with this implementation. It uses the same algorithm although modifies the original list on which it is called.