使这个功能更多 "elegant" C++

Question

有没有办法让这个递归函数更优雅？我想把功能做成没有重复的代码。

int findMaximumValue(int list[], int first, int last)
{
    if (first == last)
        return list[first];
    else {
        if (list[first] > findMaximumValue(list, first + 1, last))
            return list[first];
        else
            return findMaximumValue(list, first + 1, last);
    }
}

Answer 1

是的，您可以计算从第二个到最后一个元素的最大值，将其保存到一个变量中然后使用它：

int findMaximumValue(int list[], int first, int last)
{
    if (first == last)
        return list[first];
    else {
        int maxFromSecond = findMaximumValue(list, first + 1, last);
        if (list[first] > maxFromSecond)
            return list[first];
        else
            return maxFromSecond;
    }
}

或者，换一种方式，您可以使用函数 max(int, int) 来缩短您的函数：

int findMaximumValue(int list[], int first, int last)
{
    if (first == last)
        return list[first];
    else
        return max(list[first], findMaximumValue(list, first + 1, last));
}

Answer 2

有两件事会立即浮现在脑海中：

首先是要避免 if ... then return else ... 范式，因为 return 使 else 变得多余。
第二个是只进行递归调用一次（因为它是不变的）。

进行这些更改会给您类似的东西：

int findMaximumValue(int list[], int first, int last) {
    // List has one item, return it.

    if (first == last)
        return list[first];

    // Get largest of all but first element in list.

    int maxOfAllButFirst = findMaximumValue(list, first + 1, last);

    // First is larger than all those others, return it.

    if (list[first] > maxOfAllButFirst)
        return list[first];

    // Otherwise it's largest from the others.

    return maxOfAllButFirst;
}

不过，我应该提一下，递归最好用于解决方案 space 快速减少的算法（例如二进制搜索，您在每次递归调用时丢弃剩余解决方案 space 的一半）。

在解决方案 space 缓慢减少的情况下使用递归（例如，它基本上是线性搜索）不是最好的主意。如果它不能进行尾部调用优化，您可能会运行出栈 space 相当快。

换句话说，让这个算法更优雅的最好方法是把它从递归算法变成迭代算法:-)

Answer 3

如果允许您使用标准库中的函数，您可以将函数简化为：

int findMaximumValue(int list[], int first, int last)
{
    if (first == last)
        return list[first];

    return std::max(list[first], findMaximumValue(list, first + 1, last));
}

如果不允许您使用标准库中的任何函数，请编写您自己的 max 函数并使用它。

Answer 4

这是一个替代方案，调用时 next=1，last=列表项数，currMax 作为列表的第一项

int findMaximumValue(int list[], int nextIndex, int last, int currMax)
{
    if (nextIndex == last)
        return currMax;

    int max = list[nextIndex] > currMax ? list[nextIndex] : currMax;
    return findMax(list, ++nextIndex, last, max);
}

Answer 5

最优雅的代码;)

int findMaximumValue(void* list, int nextIndex, int last, int sizeofelem)
{
    int result;
    __asm {  
          push eax
          push ecx  
          push esi
          push edi       
          mov eax, nextIndex
          mov ecx, eax
          mul sizeofelem      
          mov esi, list       
          add esi, eax
          mov edi, esi
next:                     
          cmp ecx, last
          je  stop
comp: 
          add esi, sizeofelem
          inc ecx
          mov eax, [edi]
          cmp eax, [esi]          
          jl setgrte
          jmp next                
setgrte:  
          mov edi, esi
          jmp next
stop: 
          mov eax, [edi]
          mov [result], eax
          pop edi
          pop esi           
          pop ecx                                 
          pop eax
    } 
    return result;
}
//.....
int res = findMaximumValue((void*)&arr, lov, hiv, sizeof(int));

Answer 6

如何摆脱你的功能，只使用这个标准算法：

std::max_element(list, list + len);

http://www.cplusplus.com/reference/algorithm/max_element/

或对列表进行排序：

  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  std::sort(myvector.begin(), myvector.end(), std::greater<>()); //sort descending

  return *(myvector.begin());

使这个功能更多 "elegant" C++

Making this function more "elegant" C++

c++

performance

recursion

processing-efficiency