I tried reversing a linked list using an recursion approach but got an segmentation error? What went wrong?

#include <iostream>
class node {
public:
int data;
node* next;
node(int val) : data(val) {
this->next = nullptr;
}
};
class linkedlist {
public:
node* head;
linkedlist() {
this->head = nullptr;
}
void print() {
while(head != nullptr) {
std::cout << head->data << " ";
head = head->next;
}
}
void push(int val) {
if (head == nullptr) {
head = new node(val);
return;
}
node* temp = new node(val);
temp->next = head;
head = temp;
}
// node* recursive_reverse(node* head) {
//     if (head == nullptr || head->next == nullptr) return head;
//     node* _rest = recursive_reverse(head->next);
//     head->next->next = head;
//     head->next = nullptr;
//     head = _rest;
//     return head;
// }
node* rr_bourne_again(node* head) {
if (head->next == nullptr) return head;
node* temp = new node(0);
temp->next = head;
head = temp;
node* _rest = rr_bourne_again(head->next);
head->next->next = nullptr;
head = _rest;
delete(temp);
temp = nullptr;
return head;
}
};
int main()
{
linkedlist ll;
for (int i = 10; i > 0; i--) ll.push(i);
// ll.head = ll.recursive_reverse(ll.head);
ll.head = ll.rr_bourne_again(ll.head);
ll.print();
}

I intend to push a temp node to the head of the list, making it the new head. Then I separate the list into two parts - the new head node and the rest, namely the original list. I would reverse the rest list then link it to a nullptr. Finally I would free up the memory allocated to temp node.

I was expecting something like this in the terminal:
10 9 8 7 6 5 4 3 2 1%

but something must have went south and i got a segmentation error instead.
zsh: segmentation fault

What went wrong?

In the code you have commented out a function that would do the job perfectly, so I guess your question is only to know what went wrong with your attempt at it:

Your code first creates a dummy node, then prefixes that node to the current linked list, and then ... passes the node that follows that dummy node as argument to the recursive call. Let's visualise those steps with an example list with values 1 and 2:

                     head
↓
┌──────────────┐    ┌──────────────┐
│ data: 1      │    │ data: 2      │
│ next: ───────────►│ next: nullptr│
│              │    │              │
└──────────────┘    └──────────────┘

node* temp = new node(0); creates a new node, so we get this:

 temp                head
↓                   ↓
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ data: 0      │    │ data: 1      │    │ data: 2      │
│ next: nullptr│    │ next: ───────────►│ next: nullptr│
│              │    │              │    │              │
└──────────────┘    └──────────────┘    └──────────────┘

temp->next = head; creates the link:

 temp                head
↓                   ↓
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ data: 0      │    │ data: 1      │    │ data: 2      │
│ next: ───────────►│ next: ───────────►│ next: nullptr│
│              │    │              │    │              │
└──────────────┘    └──────────────┘    └──────────────┘

...and then it is made the head by head = temp;

 temp head
↓    ↓
┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│ data: 0      │    │ data: 1      │    │ data: 2      │
│ next: ───────────►│ next: ───────────►│ next: nullptr│
│              │    │              │    │              │
└──────────────┘    └──────────────┘    └──────────────┘

Then the recursive call is made by passing head->next as argument, but head->next is the node with data 1, so this is what the recursive execution will see:

                     head
↓
┌──────────────┐    ┌──────────────┐
│ data: 1      │    │ data: 2      │
│ next: ───────────►│ next: nullptr│
│              │    │              │
└──────────────┘    └──────────────┘

The new local variable head points to the exact same node as the node we started with! So the "problem" of reversal has not been simplified... we didn't make any progress when making the recursive call. NB: I did not depict the dummy node that was created earlier, as this recursive execution context has no access to it, so it isn't relevant.

Now the process continues as from the top, and the only thing that can end this chain of recursive calls is a memory shortage. Most likely stack memory will run out first, but also heap memory is consumed by the dummy nodes that are repeatedly created. Note that there really is no need to create dummy nodes for a list reversal.

The correct code you already have does not pass the same node pointer to the recursive call, but a pointer to a shorter list, which guarantees that the recursion will stop at a certain point.

Also, the correct code can cope with an empty list, as it tests for head == nullptr.

You'll find it easier to swap the next pointer before recursing. But that means you need to pass head->next->next as well as head->next to each recursive step.

node* recursive_reverse_impl(node* left, node* right) {
if (right == nullptr) {
return left;
}
node* nextRight = right->next;
right->next = left;
return recursive_reverse_impl(right, nextRight);
}
node* recursive_reverse(node* head) {
node* newHead= recursive_reverse_impl(head, head ? head->next : nullptr);
if (head) {
head->next = nullptr;
}
return newHead;
}