在链表中递归查找最低编号

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()的调用。 依次使用下一个节点作为参数再次调用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都不会为null，主要是因为我不知道在空列表的情况下要做什么。这两种方法都可以在lowValue的开头捕获它。）

更快，更安全，更简单。 递归很棒，因为通过递归思考比迭代解决问题通常要容易得多，但是编译器不能总是将其转换为迭代版本，因此，如果问题具有自然的迭代解决方案，则使用递归是过早的悲观化。

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

Answer 4

您的lowValue看起来像这样，

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

这主要是C代码，但是可以用