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

您可以将ciruclar链表制作成线性链表

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

肯定你会在链表中有某种起点（也许你的第一个指针左右）让我们称之为'root'，所以这个类看起来像这样：

class circle_list {
    node *root;

    ...

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

现在你可以用一个基本情况从这个节点迭代，如果你和根节点在同一个指针上你返回0.它会在第一次迭代中确定返回，所以你可以通过一个几种方法，例如你可以将head（默认参数）作为'nullptr'发送，并检查'head == nullptr'是否在你的基本情况之后将头设置为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
我们是列表的首位
我们位于列表中间
我们在列表的末尾，我。即我们再次到达

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

开始

shard3

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

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;
}

Answer 4

假设你有一些指向头部的固定指针，而iterator指向头部：

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

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

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

4 个答案: