查找最小值、最大值、平均值、中值和模式的程序 背景 编写一个C++程序，该程序使用用户输入一组数字，并输出最大值、最小值、平均值、中值和模式。我们知道模式可以是多个数字，所以编写代码，以便在必要时输出多个模式 样本输入

输入整数，完成后输入字母

-2 3 3 5 6 4 4 8 9 9 9 1 -2 10 10 10

样本输出 我的代码

#包括
使用名称空间std；
void main（）
{
双值，求和；
双倍平均值，最小值，最大值；
整数计数；
//初始化
总和=0.0；
计数=0；
cout>值；
最小值=最小值；
最大值=最大值；
而（值>=0.0）
{
//过程值
总和+=数值；
计数++；
如果（值>最大值）
最大值=最大值；
否则如果（值<最小值）
最小值=最小值；
//获取下一个值
cout>值；
}
如果（计数=0）
cout如果您想使用STL，可以编写如下内容（使用c++11）：

#包括
#包括
#包括
#包括
#包括
#包括
#包括
模板
标准：：对翻转对（常数标准：：对和对）
{
返回std：：pair（p.second，p.first）；
}
模板
标准：：多重映射翻转映射（常量标准：：映射和src）
{
std：：多映射dst；
std:：transform（src.begin（），src.end（），std:：inserter（dst，dst.begin（）），
翻转（U对）；
返回dst；
}
int main（）{
std：：字符串行；
std：：cout以下代码是您的代码的编辑版本，完全可以工作：

#包括
#包括
#包括
#包括
使用名称空间std；
int main（）
{
双值，求和；
双平均值，最小值=（双）无穷大，最大值=-（双）无穷大，中间值；
地图模式；
矢量数据；
整数计数，mxmode=0；
//初始化
总和=0.0；
计数=0；
cout>值）
{
//过程值
总和+=数值；
计数++；
如果（值>最大值）
最大值=最大值；
如果（值<最小值）
最小值=最小值；
模式[值]+；
mxmode=最大值（mxmode，模式[值]）；
数据。推回（值）；
//获取下一个值
cout中位数：

首先，您需要对数字进行排序。您可以将数字存储在数组中，然后使用排序算法，例如插入排序、选择排序等。一旦对数组进行排序，中位数就是中间数字。下面是插入排序实现的代码，假设您已将数字存储在
arr[]
和
length
是数组的长度

    void insertion_sort(double arr[], int length) {
      int i, j;
      double tmp; 
      for (i = 1; i < length; i++) {
        j = i;
        while (j > 0 && arr[j - 1] > arr[j]) {
          tmp = arr[j];
          arr[j] = arr[j - 1];
          arr[j - 1] = tmp;
          j--;
        }//end of while loop
        print_array(arr,5);
      }//end of for loop
    }//end of insertion_sort.

void插入\u排序（双arr[]，整数长度）{
int i，j；
双tmp；
对于（i=1；i0&&arr[j-1]>arr[j]）{
tmp=arr[j]；
arr[j]=arr[j-1]；
arr[j-1]=tmp；
j--；
}//while循环结束
打印阵列（arr，5）；
}//循环结束
}//插入和排序结束。

模式：

你可以用一个计数器来跟踪数组中的每个数字。最常见的是模式。
你有没有试过什么或给我们做作业？我试过什么，这是我的代码，到目前为止，它不允许我粘贴，因为它太长了。你需要做的不仅仅是在帖子中包含代码。你需要告诉我们的不仅仅是你的assignment是。例如，你到底遇到了什么问题，编译器或链接器错误，如果程序运行，你会得到什么输出，为什么会出错。我不知道如何计算中值，mode
，而（value>=0.0）
不允许你输入负数。你的排序复杂度为O（n^2），那么你为什么不使用内置排序？没错！但是，问题不在于复杂性。我只是举了一个例子，你可以使用任何你想要的排序。如果不考虑复杂性，那么你为什么要为新手使用复杂代码？
#include <iostream>
using namespace std;

void main()
{
    double value, sum;
    double average, minimum, maximum;
    int count;
    // initialise
    sum = 0.0;
    count = 0;
    cout << "Enter a value: ";
    cin >> value;
    minimum = value;
    maximum = value;
    while (value >= 0.0)
    {
        // process value
        sum += value;
        count++;
        if (value > maximum)
            maximum = value;
        else if (value < minimum)
            minimum = value;
        // get next value
        cout << "Enter a value: ";
        cin >> value;
    }
    if (count == 0)
        cout << "No data entry" << endl;
    else
    {
        average = sum / count;
        cout << "There were " << count << " numbers" << endl;
        cout << "Average was " << average << endl;
        cout << "Minimum was " << minimum << endl;
        cout << "Maximum was " << maximum << endl;
    }
}

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
template<typename A, typename B>
std::pair<B,A> flip_pair(const std::pair<A,B> &p)
{
    return std::pair<B,A>(p.second, p.first);
}
template<typename A, typename B>
std::multimap<B,A> flip_map(const std::map<A,B> &src)
{
    std::multimap<B,A> dst;
    std::transform(src.begin(), src.end(), std::inserter(dst, dst.begin()), 
                   flip_pair<A,B>);
    return dst;
}
int main() {
  std::string line;
  std::cout << "Enter numbers: ";
  std::getline(std::cin, line);
  std::istringstream iss(line);
  std::vector<int> elements;
  elements.reserve(1000);
  std::string elem;
  while (std::getline(iss, elem, ' ')) {
    try {
      elements.push_back(std::stoi(elem));
    } catch (...) {  }
  }
  double sum = 0.0;
  std::size_t n = elements.size();
  std::sort(elements.begin(), elements.end());
  std::cout << "max=" << elements.back() << std::endl;
  std::cout << "min=" << elements.front() << std::endl;
  for (auto &x: elements) {
    sum += x;
  }
  if (n == 0) return 1;
  std::cout << "avg=" << sum / n << std::endl;
  if (n == 1) {
    std::cout << "med=" << elements[0] << std::endl;
  }
  else if (n % 2 == 0) {
    std::size_t i = n/2;
    std::cout << "med=" << (double)(elements[i] + elements[i-1]) / 2.0 << std::endl;
  }
  else {
    std::cout << "med=" << elements[n/2] << std::endl;
  }
  std::set<int> elements_set;
  for (auto &x: elements) {
    elements_set.insert(x);
  }
  std::map<int, std::size_t> elements_count;
  for (auto &x: elements_set) {
    elements_count.insert(std::pair<int, std::size_t>(x, std::count(elements.begin(), elements.end(), x)));
  }
  std::multimap<std::size_t, int> count_elements;
  count_elements = flip_map(elements_count);
  std::cout << "mod: ";
  std::size_t count_mod = count_elements.rbegin()->first;
  for (auto &x: count_elements) {
    if (x.first == count_mod) {
      std::cout << x.second << ", ";
    }
    else {  }
  }
  std::cout << "(" << count_mod << ")" << std::endl;
  return 0;
}

    void insertion_sort(double arr[], int length) {
      int i, j;
      double tmp; 
      for (i = 1; i < length; i++) {
        j = i;
        while (j > 0 && arr[j - 1] > arr[j]) {
          tmp = arr[j];
          arr[j] = arr[j - 1];
          arr[j - 1] = tmp;
          j--;
        }//end of while loop
        print_array(arr,5);
      }//end of for loop
    }//end of insertion_sort.