在C ++中找到3个数字中最小的[重复]

Question

有什么方法可以让这个函数更优雅吗？我是 C++ 新手，我不知道是否有更标准化的方法来做到这一点。这可以变成一个循环，这样变量的数量就不会像我的代码那样受到限制吗？

float smallest(int x, int y, int z) {

  int smallest = 99999;

  if (x < smallest)
    smallest=x;
  if (y < smallest)
    smallest=y;
  if(z < smallest)
    smallest=z;

  return smallest;
}

Answer 1

如果可能，我建议使用 C++11 或更新版本，它允许您在不实现自己的函数的情况下计算所需的结果 (std::min)。正如在其中一个 cmets 中已经指出的那样，您可以这样做

T minimum(std::min({x, y, z}));

或

T minimum = std::min({x, y, z});

在T类型的变量minimum中存储变量x、y和z中的最小值（注意x、y和z必须具有相同的类型或必须隐式转换为它）。相应地，同样可以得到最大值：std::max({x, y, z})。

Answer 2

可以进行许多改进。

您可以使用标准函数使其更清晰：

// Notice I made the return type an int instead of a float, 
// since you're passing in ints
int smallest(int x, int y, int z){
    return std::min(std::min(x, y), z);
}

或者更好，正如 cmets 中指出的那样：

int smallest(int x, int y, int z){
    return std::min({x, y, z});
}

如果你想让它对任意数量的整数进行操作，你可以这样做：

int smallest(const std::vector<int>& intvec){
    int smallest = std::numeric_limits<int>::max(); // Largest possible integer
    // there are a number of ways to structure this loop, this is just one
    for (int i = 0; i < intvec.size(); ++i) 
    {
        smallest = std::min(smallest, intvec[i]);
    }
    return smallest;
}

你也可以让它通用，这样它就可以在任何类型上运行，而不仅仅是 ints

template <typename T>
T smallest(const std::vector<T>& vec){
    T smallest = std::numeric_limits<T>::max(); // Largest possible integer
    // there are a number of ways to structure this loop, this is just one
    for (int i = 0; i < vec.size(); ++i) 
    {
        smallest = std::min(smallest, vec[i]);
    }
    return smallest;
}

Answer 3

除了 min，让你写 return min(x, min(y, z)) 还有三元运算符：

float smallest(int x, int y, int z){
  return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

Answer 4

smallest=(x<((y<z)?y:z))?x:((y<z)?y:z);

假设，

x is one;
y is two;
z is three;

smallest = (one < ((two < three) ? two:three)) ? one:((two < three) ? two:three)

Answer 5

有一个建议将其包含在N2485 下的 C++ 库中。这个提议很简单，所以我在下面包含了有意义的代码。显然，这假定了可变参数模板。

template < typename T >
const T & min ( const T & a )
{ return a ; }

template < typename T , typename ... Args >
const T & min ( const T & a , const T & b , const Args &... args )
{ return std :: min ( b < a ? b : a , args ...); }

Answer 6

小改动

 int smallest(int x, int y, int z){
    int smallest = min(x,y);
    return min(smallest,z);
    }

Answer 7

1) 简单的解决方案：

int smallest(int x, int y, int z)
{
    return std::min(std::min(x, y), z);
}

2) 更好的解决方案（在优化方面）：

float smallest(int x, int y, int z)
{
  return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

3）你的解决方案修改（简单但不高效）：

int smallest(int x, int y, int z)
{

  int smallest = x;

  if (y < smallest)
     smallest=y;
  if(z < smallest)
     smallest=z;
  return smallest;
}

4) 任意数量的数字：

对于 n 个数字，将其存储在一个数组 (array[n]) 中，对数组进行排序并 将数组[0] 取最小。

    //sort the elements in ascending order
    for(int i=0;i<n;i++)
    {
      if(array[i]>array[i+1])
      {
        int temp = array[i];
        array[i] = array[i+1];
        array[i+1] = temp;
      }
    }

    //display smallesst and largest
    cout<<"Smallest: "<<array[0];
    cout<<"Largest: "<<array[n-1];   //not needed in your case
    }

Answer 8

在您的版本中，只有小于 99999 时才会找到最小值。

您应该将所有三个值一起比较。此外，您收到int，但返回float。要么，您应该决定要处理哪种类型的值，或者您可以创建一个通用版本，适用于任何可以比较的类型：

#include <algorithm>

template<class T>
T smallest(T x, T y, T z)
{
  return std::min(x, std::min(y, z));
}

编辑：

将代码改进为可在vector 上运行的东西的两种方法：

#include <cstdio>
#include <algorithm>
#include <vector>

// Use a built-in function to retrieve the smallest value automatically
template<class T>
T smallest1(const std::vector<T> &values)
{
  return *std::min_element(values.begin(), values.end());
}

// Go through the vector manually
template<class T>
T smallest2(const std::vector<T> &values)
{
  // Get the first value, to make sure we're comparing with an actual value
  T best_so_far = values.front();
  // For all the other values in the vector ...
  for(unsigned i = 1; i < values.size(); ++i) {
    // ... replace if the new one is better
    if(values[i] < best_so_far)
      best_so_far = values[i];
  }
  return best_so_far;
}

int main()
{
  // Try out the code with a small vector
  std::vector<int> test;
  test.push_back(6);
  test.push_back(5);
  test.push_back(7);

  printf("%d\n", smallest1(test));
  printf("%d\n", smallest2(test));

  return 0;
}

Answer 9

或者你可以只使用define，来创建一个宏函数。

#define min(x,y,z) (x < y ? (x < z ? x : z) : (y < z ? y : z))

Answer 10

您可以将它们存储在向量中并在其上使用std::min_element。

例如：

vector<int> values;
values.push_back(10);values.push_back(1);values.push_back(12);

int min = *std::min_element(values.begin(),values.end());