Problem with recursion function

[DoABarrelRoll94]

The recursion function int LinkedList::recurDist(Node* curr) on line 71 is supposed to calculate the sum of the distances from LGA to the airport code typed in by the user, but it always returns 0.

#include <iostream>
#include <string>
#include <unistd.h>         //sleep(),
using namespace std;

int sum = 0;                //declaration of sum variable to hold sum, init to 0.

class Node
{
private:
    string airportCd;
    int distance;
    Node* next;
    Node* prev;
    
    friend class LinkedList;
};

class LinkedList
{
private:
    Node* header;
    Node* trailer;
    Node *curr;
public:
    LinkedList();                                                   //constructor
    void insertNode(Node*, const string&, const int&);          //insert new node
    void printList();                                               //function to print the linked list
    void menu();                                                    //menu for user selection
    int recurDist(Node*);                                //calculate distance from LGA to selected airport using recursion
    void iterDist(const string&);                                 //calculate distance from LGA to selected airport using iteratrion
};

//*********************//
//LINKED LIST FUNCTIONS//
//*********************//

LinkedList::LinkedList()        //constructor
{
    header = new Node;
    header->airportCd = "LGA";
    header->distance = 0;
    trailer = new Node;
    header->next = trailer;
    trailer->prev = header;
}

void LinkedList::insertNode(Node* nextloc, const string& e, const int& f)       //insert new node
{
    Node* t = new Node;
    t->airportCd = e;
    t->distance = f;
    t->next = nextloc;
    t->prev = nextloc->prev;
    nextloc->prev->next = t;
    nextloc->prev = t;
    cout << endl;
}

void LinkedList::printList()        //print linked list
{
    curr = header;
    while (curr->next != trailer)
    {
        cout << curr->airportCd << " ";
        cout << curr->distance << " miles." << endl;
        curr = curr->next;
    }
}

int LinkedList::recurDist(Node* curr)         //calculate distance from LGA to selected airport using recursion
{
    if(curr->airportCd == header->airportCd)
    {
        return 0;
    }
    else return sum + recurDist(curr->prev);
}

void LinkedList::iterDist(const string& e)          //calculate distance from LGA to selected airport using iteration
{
    curr = header;
    while (curr->airportCd != e)                    //while the current pointer is not pointing to the chosen airport cd's node
    {
        sum = sum + curr->distance;
        curr = curr->next;
    }
    if(curr->airportCd == e)                        //if the current ptr is pointing at the chosen airport cd's node
    {
        sum = sum + curr->distance;
    }
    cout << sum << " miles.\n\n";
}

void LinkedList::menu()                             //menu
{
    int distance;
    string airPCd;
    int choice;
    do{
        cout << "Menu: Select choice(1-3). Enter 4 to quit.\n";
        cout << "-------------------------------------------------------------\n\n";
        cout << "1)Enter new airport information.[Starting airport is LGA.]\n\n";
        cout << "2)Specify an existing airport code and calculate the distance\nfrom LGA to the selected airport using recursion.\n\n";
        cout << "3)Specify an existing airport code and calculate the distance\nfrom LGA to the selected airport by looping thru ";
        cout << "the nodes in\nstandard fashion.\n\n";
        cin >> choice;
        switch(choice)
        {
            case 1:
                curr = trailer->prev;
                cout << "Enter airport code.\n";
                cin >> airPCd;
                if(curr == header)                                                         //if header points to trailer
                {
                    cout << "Enter distance from " << header->airportCd << ".[In miles]\n";        //from "LGA"
                }
                else                                                                                //else
                {
                    cout << "Enter distance from " << curr->airportCd << ".[In miles]\n";    //from prev airportCd
                }
                cin >> distance;
                insertNode(trailer, airPCd, distance);
                break;
            case 2:
                cout << "Enter an airport code.\n";
                cin >> airPCd;
                curr = header;
                while(curr->airportCd != airPCd)
                {
                    curr = curr->next;
                }
                cout << recurDist(curr) << " miles.\n\n";      //call function to sum distance from LGA to chosen airport code
                break;
            case 3:
                cout << "Enter and airport code.\n";
                cin >> airPCd;
                iterDist(airPCd);
                break;
            case 4:
                return;
            default:
                cout << "YOU HAVE ENTERED AN INVALID NUMBER!!!\n\n";
        }
    }while(choice != 4);
    
    
}

int main()
{
    LinkedList passenger;
    
    passenger.menu();
    
    for(int i = 0; i < 3; i++)
    {
        cout << ".";
        cout << flush;              //flush out buffer
        sleep(1);                   //prints 1 dot every second
    }
    
    cout << "Finito.\n";
    
    return 0;
}

[AbstractionAnon]

line 6: What makes you think using a global here is a good idea?

Consider if you loop through menu more than once, you never reset sum.

[DoABarrelRoll94]

I thought that if I declared it in the recursion function, it would also reset to 0 when it recursively calls itself, so I made it global.

[cire]

Consider if you loop through menu more than once, you never reset sum.

I don't think that matters since, with the current logic in the program, sum will never be anything but 0.

I thought that if I declared it in the recursion function, it would also reset to 0 when it recursively calls itself, so I made it global.

If a recursive function needs to keep track of something like that, you generally make it a parameter to the function.

Let me say that a linked list of airports is a particularly shoddy representation of flight paths. This should be implemented with a graph.

I suspect your recursive function should look something like this:

int LinkedList::recurDist(Node* curr)         //calculate distance from LGA to selected airport using recursion
{
    if(curr->airportCd == header->airportCd)
    {
        return 0;
    }
    else 
        return curr->distance + recurDist(curr->prev);
}

Although it doesn't take into account the direction in which the list needs to be iterated and could use a sanity check or two.

[DoABarrelRoll94]

Haha yeah linked List was the way my professor told us to do it. We didn't cover graphs yet. Thanks, it works now. I don't quite get why though it wouldn't work with sum. Can you explain why?

[cire]

Your function returned sum + recurDist(curr->prev), but sum was zero. The only other value returned from the function was... also 0. So you either returned 0 or 0+0.