在链表中查找值的递归方法

Question

template<class Type>
int StringList<Type>::find(Type value)
{
int count = 0;

// Start of linked list
Node<Type> *current = head;

// Traverse list until end (NULL)
while (current != NULL)
{
    // Increase counter if found
    if (current->data == value)
    {
        count++;
    }

    // If not, move to the next node
    current = current->next;
}

cout << value << " was found " << count << " times" << endl;

return 0;





// same function but using Recursive method





// Start of linked list
Node<Type> *current = head;
int count = 0;

// Thinking this is the base case, since its similar to the while loop
if (current == NULL)
{
    return 0;
}

// same as the while loop, finding the value increase the count, or in this case just prints to console
if ((current->data == value))
{
    cout << "Found match" << endl;
    return 0;
}
else
{   // If it didnt find a match, move the list forward and call the function again
    current = current->next;
    return find(value);
}

}

该函数应该找到所搜索的值并返回该特定值在链表中的次数。

如何将使用while循环的第一种方法转换为执行相同操作但使用递归的方法？

Answer 1

为了使用递归，您将需要更改find​​函数的签名（或添加具有不同签名的新函数）以将节点指针作为参数：

template<class Type>
int StringList<Type>::find(Type value, Node<Type> *where)
{
    if (where != nullptr)
    {
    // Do things
    }
}

然后，遍历列表时，将where->next传递给函数。 一旦您以nullptr值到达列表的末尾，堆栈便会展开。

递归的一个关键方面是，所使用的函数或方法仅需要处理容器的单个节点。 然后，它使用下一个要处理的节点调用自身，直到没有更多节点为止。 为了使这项工作有效，该函数需要将节点作为参数进行处理，这是当前代码遇到问题的地方。

请记住，递归的优雅和简单并不是免费的。 方法对自身的每次调用都会耗尽堆栈，因此，如果进程的堆栈耗尽，那么足够大的容器可能会导致崩溃。

Answer 2

对于初学者，而不是返回类型int ，最好使用无符号类型，例如size_t

您可以使用以下方法。 定义两种方法。 第一个是一个公共的非静态方法find等被定义

template<class Type>
size_t StringList<Type>::find( const Type &value ) const
{
    return find( head, value );
}

第二个是私有静态方法，其中定义了两个参数，例如

template<class Type>
static size_t StringList<Type>::find( Node<Type> *current, const Type &value )
{
    return current == nullptr ? 0 : ( current->data == value ) + find( current->next, value );
}

Answer 3

如何将使用while循环的第一种方法转换为执行相同操作但使用递归的方法？

以下内容将更接近您想要的内容。 您确实应该提供[MCVE] ...缺少它会导致对代码的许多猜测和假设。

// It looks like StringList is a class (I ignored template issues), 
// and it appears that your class holds 'anchors' such as head
//   StringList is probably the public interface.
//   
// To find and count a targetValue, the code starts 
//   at the head node, and recurses through the node list.
// I would make the following a public method.
//
int StringList::findAndCountTargetValue(int targetValue)
   {
      int retVal = 0;

      if (nullptr != head)          // exists elements to search?
         retVal = head->countTV(targetValue); // recurse the nodes

      // else no match is possible

      return(retVal);
   }


// visit each node in the list 
int Node::countTV(const int targetValue)
   {
      int retVal = 0;  // init the count

      if (data != targetValue)  // no match
      {
         if(nullptr != next)            // more elements?
            retVal += next->countTV()   // continue recursive count
      }
      else
      {
         std::cout << "Found match" << std::endl;   // for diag only

         retVal += 1; // because 1 match has been found

         if(nullptr != next)           // more elments
            retVal += next->countTV(); // continue recursive count
      }

      return (retVal);  // always return value from each level
   }