Why this function is not able to reverse the Linked List?

Question

I want to reverse a linked list but when i compile this code it terminates unexpectedly.

#include <bits/stdc++.h>
using namespace std;

class node{
public:
    int data;
    node* next;

    node(int val){
    data=val;
    next=NULL;
        }
};

For Inserting Elements in Linked List

void insertattail(node* &head,int lol){
    node* n= new node(lol);
    if(head==NULL){
        head=n;
        return;
    }
    node* temp=head;
    while(temp->next!=NULL){
        temp=temp->next;
    }
    temp->next=n;
}

Display Function to print linked list

void display(node* head){
    node* temp =head;
    do{
        cout<<temp->data<<"->";
        temp=temp->next;
    }
    while(temp!=NULL);
    cout<<"Null";

}

Function to reverse Linked List

node* reverseit(node* head){
    node* prevptr= NULL;
    node* currptr= head;
    node* nextptr= currptr->next;
    while(currptr!=NULL){
        currptr->next =prevptr;
        prevptr=currptr;
        currptr=nextptr;
        nextptr=currptr->next;
    }
    return prevptr;
}

Main Function

int main()
{
    node* head= NULL;
    insertattail(head,1);
    insertattail(head,2);
    insertattail(head,3);
    insertattail(head,8);
    node* newhead= reverseit(head);
    display(newhead);
    return 0;
}

I think the problem is in logic of reverse function. I just used the code for linked list and made small changes.

Answer 1

Your initialization and 'incrementing' of nextptr both (potentially/eventually) dereference a NULL value of currptr. You should initialize nextptr to NULL and only change that to the 'real' next if currptr is not NULL; thus, its (re)assignment should be at the start of the loop, not at the end:

node* reverseit(node* head){
    node* prevptr = nullptr;
    node* currptr = head;
    node* nextptr = nullptr; // Don't assume a non-NULL currptr
    while (currptr != nullptr) {
        nextptr = currptr->next; // Safe here: save next
        currptr->next = prevptr; // Do the reversal here
        prevptr = currptr;       // Step forward through
        currptr = nextptr;       // the list (prev/curr)
    //  nextptr = currptr->next; // WRONG HERE: currptr will be NULL at some point
    }
    return prevptr;
}