仅给定头指针，递归计算循环链表中的节点数

Question

我正在编写这个函数作为作业的一部分。如果包含尾指针并且大部分代码由我的讲师提供并包含在目标文件中，那也没什么大不了的，所以我没有要包含的实现。无论如何，由于某种原因，我的函数中的基本情况永远不会达到。谁能告诉我为什么这一直在循环？

#include "clist.h"
#include <iostream>

using namespace std;

struct node
{
    int     data;
    node*   next;
};

//Iteratively compute and return the number of nodes in the circular linked list
int count(node* head)
{
    int nodeTotal = 1;
    node* temp = head;
    while(temp->next != head)
    {
        nodeTotal++;
        temp = temp->next;
    }
    return nodeTotal;
}


//Recursively compute and return the number of nodes in the circular linked list
int countR(node* head)
{
    node* temp = head;
    if(temp->next == head)
        return 0;
    else
        return 1 + countR(temp->next);
}


//Iteratively compute and return the sum of the ints contained in the circular linked list
int sum(node* head)
{
    int valuesTotal = 2;
    node* temp = head;
    while(temp->next != head)
    {
        valuesTotal += temp->data;
        temp = temp->next;
    }
    return valuesTotal;
}

int main()
{
    node* head{nullptr};

    /* Builds a circular linked list with a random number of nodes
    *containing randomly-chosen numbers.
    */
    build(head);

    display(head);  

    // PUT YOUR CODE HERE to call the functions assigned,
    // and print out the results. For example,
    //
    //    cout << "iterative sum: " << sum(head) << endl;
    //
    // The code for your functions should be in clist.cpp.
    cout << "\nIterative node count: " << count(head) << endl;
    cout << "Iterative sum: " << sum(head) << endl;
    cout << "Recursive node count: " << countR(head) << endl;

    // When called the 2nd time, this also prints the total
    // of the numbers in the nodes.
    display(head);




    int     nNodesFreed{0};
    node*   n{head};
    node*   temp;

    while( n != head || ! nNodesFreed) {
        temp = n->next;
        delete n;
        n = temp;
        nNodesFreed++;

        }
    cout << "# nodes freed: " << nNodesFreed << endl;

    //destroy(head);

    return 0;
}

Answer 1

您的停止条件不起作用，因为每次进行递归调用时，都会从一个新的 head 指针开始。所以，假设你从一个这样的链表开始：

在第一次调用时，您传递 A（嗯，A 的地址），它会检查 A == B 是否。它没有，所以它执行一个递归调用传递 B。在那个调用中，它检查 B == C 是否失败，所以它通过 C 进行递归调用。 检查 C == D 是否失败，所以它检查 D == E 是否失败，所以它检查是否 E == A . 那失败了，所以它检查是否 A == B。那仍然失败，所以它继续...

它转来转去。它停在哪里，没人知道！