c++循环链表的递归基本情况

Question

这都是假设，

我有一个这样的结构：

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

和一个只有一个头指针的循环链表，我将如何为一个计算循环链表节点的递归函数设置一个基本情况？我什至不知道从哪里开始，因为我集思广益，很快意识到行不通，因为列表中的最后一个节点直接指向头部而不是 NULL。

示例函数：

int count(node *head)
{
   int listCount = 0;

   if(base case)
   {
     then return 0;
   }
   else
   {
     calculate listCount
     count(head->next);
   }

   return listCount
}

Answer 1

你可以把循环链表变成线性链表

int wrapper_function(node*head)
{
    node*current = head;
    head  = head -> next;
    current -> next = NULL;
    count(head);
    current -> next = head;
    head = current;
    return 0;
}


int count(node *head)
{
   int count = 0;

   if(!head)
   {
   then return 0;
   }
   else
  {
   calculate count
   count(head->next);
  }

   return;
}

Answer 2

为了确保您将在链表中找到某种起点（可能是您的第一个指针左右），例如，我们将其称为“根”，这样该类将如下所示：

class circle_list {
    node *root;

    ...

    public:
    int count(node *head);
};

现在你可以从这个节点迭代一个基本情况，如果你和根节点在同一个指针上，你返回 0。它会在第一次迭代中返回，所以你可以通过这个问题几种方法，例如，您可以将 head（默认参数）作为“nullptr”发送并检查“head == nullptr”是否在基本情况之后将 head 设置为 root：

int count(node *head = nullptr) {
    if (head == root) {
        return 0;
    }

    if (head == nullptr) {
        head = root;
    }

    return 1 + count(head->next);
}

这里有很多可能性，当然这只是可能的想法之一。

Answer 3

好吧，我们必须区分：

• 空列表，head 为 nullptr
• 我们位居榜首
• 我们在列表中间
• 我们位于列表的末尾，即。 e.我们再次到达头部

为了能够区分，您需要跟踪头部！在给定的情况下，通过简单的迭代来完成任务会更容易，所以让我们开始吧：

unsigned int count(node* head)
{
    if(head == nullptr)
        return 0;
    unsigned int n = 1;
    node* current = head->next; // start at next element!
    while(current != head)      // only way to detect end!
    {
       ++n;
       current = current->next;
    }
    return n;
}

现在，如果您坚持使用递归函数：由于我们需要跟踪头部，我们需要两个指针。没办法。但是我们可以提供一个单独的入口函数，只接受头部，然后将两个指针传递给实际的递归函数：

unsigned int count(node* head)
{
    if(head == nullptr)
        return 0;
    return count(head, head->next);
}
unsigned count(node* head, node* current)
{
    if(current == head) // our end condition!
        return 1;
    return 1 + count(head, current->next);
}

Answer 4

假设你有一些指向 head 的固定指针，iterator 指向 head：

count(node *head, node *iterator, int *numOfElem)
{      

   if(head==iterator)
      return;
   else
     { 
        (*numOfElem)++;
        count(head, iterator->next, numOfElem);
     }
}