recursively reverse a linked list without a global variable - c++

Question

I wonder why passing the second parameter Node** fhead causes a segfault? Node has an int value and a next pointer pointing to the next Node.
Here is my code:
void reverse(Node* head, Node** fhead) {
if (!head->next)
{
fhead = &head;
return;
}
reverse(head->next, fhead);
head->next->next = head;
head->next = 0;
}
int main()
{
Node a = {1, 0};
Node b = {2, &a};
Node c = {3, &b};
Node** fhead;
reverse(&c, fhead);
}

Answer 1

You have a little mistake in the recurssion termination. You should set *fhead to head and not assigning it with &head (Which will just change fhead locally in the funciton):
if (!head->next)
{
*fhead = head;
return;
}

Answer 2

There are two very small but serious problems.
First,
fhead = &head;
assigns a value to the parameter, so that change will not be visible outside of the function.
This works exactly like
void f(int x)
{
x = 0;
}
Just like you would do when you pass e.g. a pointer to an int,
void f(int* x)
{
*x = 0;
}
you need to assign to the object that the pointer points to:
*fhead = head;
Second, you need to pass a valid pointer to a variable:
Node* fhead = 0;
reverse(&c, &fhead);
(The initialisation isn't strictly necessary, but it's a good idea to initialise variables.)
With those two changes, your code works as expected.

Answer 3

public ListNode reverseList(ListNode head) {
if (head == null || head.next == null)
return head;
ListNode p = reverseList(head.next);
head.next.next = head;
head.next = null;
return p;
}
One can assume ListNode definition
class ListNode{
int val;
ListNode next;
public ListNode(int val){
this.val = val;
this.next = null;
}
}