Question

我在下面使用此代码返回向量中最小的正整数。我得到了代码here。我的问题是有理由将大小传递给函数，你能不在函数体中计算它吗？

第二次if()测试是什么？我无法理解这个if语句是如何工作的？

#include <vector>
using namespace std;
int rec_min_pos(const vector<int> & nums, int size) {
    if (size < 1) {
        return INT_MAX;
    }
    if(nums[size-1] > 0){
        return min(nums[size-1], rec_min_pos(nums, size-1));
    }
    else{
        return rec_min_pos(nums, size-1);
    }
}

Answer 1

第二个if语句检查元素的积极性，因为函数应返回最小正整数。

您的功能是递归的，并且size＆＃39;参数实际上是一个加上要测试的最后一个元素的索引。这允许简单的递归函数设计，但需要额外的参数。在功能界面

中明确提出这些要点可能更好

inline int recursive_min_positive(const int*arr, size_t i)
{
    return 
        i==0? std::numeric_limits<int>::max() :
        arr[i-1]<=0? recursive_min_positive(arr,i-1) :
        std::min(arr[i-1],recursive_min_positive(arr,i-1) ;
}

int min_positive(std::vector<int> const&arr)
{
    return recursive_min_positive(arr.data(), arr.size());
}

递归函数设计通常很优雅，但效率低（尽管编译器倾向于展开递归）。在这里，非递归实现实际上更短更清晰。

int min_positive(std::vector<int> const&arr)
{
    int result = std::numeric_limits<int>::max();
    for(auto val : arr)
        if(0 < val  &&  val < result) result = val;
    return result;
}

Answer 2

除了所有注释：你可以像这样重载函数：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// Original function with size argument
int rec_min_pos(const vector<int> & nums, int size) {
  if (size < 1) {
    return INT_MAX;
  }
  if (nums[size - 1] > 0) {
    return min(nums[size - 1], rec_min_pos(nums, size - 1));
  }
  else {
    return rec_min_pos(nums, size - 1);
  }
}

// Overloaded rec_min_pos function
int rec_min_pos(const vector<int> & nums) {
    // here we just call the original rec_mon_pos function
    return rec_min_pos(nums, nums.size());
}

int main()
{
  vector<int> v{ 9,2,7,3,7,5,6 };
  cout << rec_min_pos(v);  // call the overloaded function
}

输出：

Answer 3

与递归函数无关，但扩展了我的评论：

int min_positive(std::vector<int> & nums)
{
    auto elem = std::min_element(nums.begin(), nums.end(), 
        [](int lhs, int rhs){ return std::tie(std::signbit(lhs), lhs) < std::tie(std::signbit(rhs), rhs); }
    );
    if ((elem == nums.end()) || std::signbit(*elems)) { return MAX_INT; }
    return *elem;
}

这里我们定义一个比较函数，它在负数之前订购正数，然后按价值订购。我们使用三个参数std::min_element，它将在nums中找到一个迭代器。

第一个检查处理空nums，第二个检查处理每个值为负数，原始忽略，返回MAX_INT

c ++函数返回向量中最小的正整数

3 个答案: