Question

我试图在我创建的链接列表中找到最低值，我需要递归地找到这个，如何解决这个问题？

以下是我的标题

// Header file for the IntList class

#ifndef INTLIST_H
#define INTLIST_H

#include <iostream>

class IntList
{
    private:
        struct ListNode // Used for nodes
        {
            int value;
            ListNode * next;
        };
        ListNode * head; // Address of the 1st node
        int sum, high_value;
        int lowValues(ListNode *);
    public:
        IntList();                  //Constructor
        IntList(IntList &);         //Copy constructor
        void appendNode(int);       //Adds a new node to end of list
        void insertNode(int);       //Inserts a num into list
        void deleteNode(int);       //Deletes a num from list
        void displayList() const;   //Displays list
        int sumList();              //Returns sum of list
        int highValue();            //Finds highest value in the list
        ***int lowValue(ListNode *)    //Finds low value using recursion***
        { return lowValue(head); }
        ~IntList();                 //Destructor
};

Answer 1

不要在C ++中滚动自己的链表。标准库中有两个--std :: list是双向链表，std :: forward_list是单链接的。还有一种标准算法可以在一个范围内找到min元素：

std::list<int> intList = {1, 2, 3};

int minimum = *(std::min_element(std::begin(inList), std::end(intList)));

我看到你的列表类存储的信息比列表更多，但是通过使用这个算法和标准容器，你根本不需要你的类。除非当然，这是编写链表类的赋值;）

Answer 2

高级草图：

如果我是列表的最后一个元素，请将自己视为“最低”
否则，请返回我自己和“列表其余部分”中的较小者。

这就是本质。如果你写不好，请告诉我们你陷入困境的地方。

Answer 3

（我可能会因为生锈的C ++而使自己难堪，但这个问题的关键在于语言无关，所以要点应该是可以理解的。）

private:
static int lowValueForNode(ListNode* node)
{
  ListNode* next = node->next;
  if(next == 0)
    return node->value;
  int fromNext = lowValueForNode(next);
  return fromNext < node->value ? fromNext : node-> value;
}
public:
int lowValue()
{
  return lowValueForNode(head);
}

对lowValue()的调用首先调用lowValueForNode()，head作为参数。这反过来再次调用lowValueForNode()作为其参数的下一个节点，并一直这样做，直到到达最后一个节点，在这种情况下，它只返回节点值。

当每次调用返回时，将返回值与当前节点的值进行比较，以便返回两者中的较低者，依此类推，直到列表中的最小值为最终结果。

然而，这不是一个好主意。所有这些函数调用都是不必要的开销，在一定大小的列表中会导致调用堆栈溢出。使用它会好得多：

int lowValue()
{
  int ret = head->value;
  for(ListNode* node = head->next; node != 0; node = node->next)
    if(node->value < ret)
      ret = node->value;
  return ret;
}

（我假设head在这两种情况下永远不会为空，主要是因为我不知道在空列表的情况下你想做什么。无论哪种方式都可以在开始时捕获它lowValue）。

更快，更安全，更简单。递归是很好的，因为通过递归思考而不是迭代地解决问题通常要容易得多，但是编译器不能总是把它变成迭代版本，所以如果问题有一个自然的迭代解决方案，那么使用递归是过早的悲观。 / p>

（至少，在命令式语言中;在一些声明性语言中，递归既是一种更自然的方法，也更可能是优越的，甚至是唯一的方法。）

Answer 4

你的lowValues看起来像这样，

int lowValues(ListNode *n){
if(n!=NULL){
int k=lowValues(n->next);
return (k<n->value)?k:n->value;
}
}

这主要是C代码，但它可以正常工作

递归查找链表中的最小数字

4 个答案: