Recursive function for Linked List (missing first value)

[MikeCheezy]

Hi there! I have been brushing up on Linked List as personal practice, and I have recently implemented a Linked List class in List.h as shown below:

#ifndef LIST_H
#define LIST_H

class List
{
private: // can only be accessed by functions declared here
    
    typedef struct node
    {
        int data;
        node* next; //node pointer, purpose is to point to another node
        
    }* nodePtr;
    
    //typedef struct node* nodePtr; //type nodePtr, same as struct node*
    
    nodePtr head;
    nodePtr curr;
    nodePtr temp;
    
    
public: // This is where functions go
    List(); // Constructor, sets initial values of NodePtr
    void AddNode(int addData);
    void DeleteNode(int delData);
    void PrintList();
    void ReverseList();
    void callReverse();
    void ReverseRec(node* pointer);
    
    
};
#endif /* LIST_H */  

I have got the iterative way of reversing the Linked List correct, but when I tried to implement the recursive way, I am running into an issue where the initial head value is missing from my print function.

For example: 3 5 7 -> callReverse -> printList -> 7 5 (missing the 3)

Here is the code for my Linked List functions below:
The code in question is ReverseRec and callReverse (both required for recursive calls)

<#include <iostream>
#include <cstdlib>

#include "List.h"

using namespace std;

List::List()
{
    head = NULL;
    curr = NULL;
    temp = NULL;
}

void List::AddNode(int addData)
{
    nodePtr n = new node;
    n->next = NULL;
    n->data = addData;
    
    //if list is already created(we have at least one elem in list)
    if(head != NULL) //can access privata data "head" because public function
    {
        curr = head;
        while(curr->next != NULL)
        {
            curr = curr->next;
        }
        curr->next = n;
    }
    
    else
    {
        head = n;
    }
}

void List::DeleteNode(int delData)
{
    nodePtr delPtr = NULL;
    temp = head;
    curr = head;
    while((curr != NULL) && curr->data != delData)
    {
        temp = curr;
        curr = curr->next;
    }
    if(curr == NULL) 
    {
        cout << "Data was not found.\n";
        delete delPtr;
    }
    
    else
    {
        delPtr = curr;
        curr = curr->next;
        temp->next = curr;
        delete delPtr;
        cout << "The value " << delData << " was deleted.\n";
    }
    
}

void List::PrintList()
{
    curr = head;
    while(curr != NULL)
    {
        cout << curr->data << " ";
        curr = curr->next;
    }
}

void List::ReverseList()
{
    if(head == NULL) return;
    
    nodePtr prev = NULL;
    curr = head;
    while(curr != NULL)
    {
        temp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = temp;
    }
    
    head = prev;
}

void List::callReverse(){
    
    nodePtr h = head;
    head = NULL;
    ReverseRec(h);
}

void List::ReverseRec(nodePtr pointer)
{
    if(pointer->next == NULL)
    {
        if(head == NULL)
            head = pointer;
    }
    else if(pointer->next->next!=NULL)
    {
        ReverseRec(pointer->next);
    }
    
    if(head == NULL)
    {
        head = pointer->next;
        pointer->next->next = pointer;
        pointer->next = NULL;
    }
} 

Any tips/advice would be appreciated! Thank you.

Here's the main.cpp as well if you were curious

#include <cstdlib>

#include <iostream>

#include "List.h"

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {

    List list;
    
    list.AddNode(3);
    list.AddNode(5);
    list.AddNode(7);
    list.callReverse();
    list.PrintList();
    
    return 0;
}

[Nico]

I think it could be something like this.

void List::callReverse(){

    nodePtr h = head;
    head = nullptr;
    ReverseRec(h);
}

void List::ReverseRec(nodePtr pointer)
{
    nodePtr temp = new node;
    temp->data = pointer->data;    // copy the data
    temp->next = nullptr;          // prevent that we create a graph with a loop instead of a list
    if(pointer->next == nullptr)   // we found the tail node, this should be the first node to add to the reversed list
    {
        head = temp;                // add this node to the reversed list
        curr = head;                // and make it simple to add another node if there are more
    }
    else                            // this is not the first node to add to the reversed list
    {
        ReverseRec(pointer->next);  // it is this nodes turn when this function call returns
        curr->next = temp;          // finally add it
        curr = temp;                // and make it simple to add another node if there are more
    }
}

[doug4]

@OP,

I think if you take lines 114 and 115 and move them to after the curly brace on line 116 your program will work. The problem is, you are only adjusting the next pointers when head == NULL which won't be true at this point in the recursive call except for in the last recursion.