C++ 如何交换数组中的最小和最大值位置？

在代码中，我找到了任何给定数组的

min

和

max

值。现在我想交换他们的位置，并打印出来。如

Min

位于

Max

位置，反之亦然。我怎样才能改变他们的立场？我想我做错了

#include <iostream>

using namespace std;

int main()
{
    int array[8] = { 0, 0, 0, 0, 0, 0, 0, 0}; 
    int min = array[0]; 
    int max = array[0]; 
    int indexOfMin = 0; 
    int indexOfMax = 0; 
    int arrSize = sizeof(array)/sizeof(array[0]); 
    int temp = 0; 

    cout << "Enter an array: "; 

    int k;
    for(k = 0; k <= arrSize; k++){ 
        cin >> array[k];
    }

    for (int i = 0; i < arrSize; i++){ 
         if(array[i] >= max ){          
            max = array[i];            
            indexOfMax = i;            
        }
    }

    for (int i = 0; i < arrSize; i++){ 
        if(array[i] == min){           
            continue;
        }
        if(array[i] < min){
            min = array[i];
            indexOfMin = i;
        }
    }

    temp = min;
    min = max;
    max = temp;

    cout << array[k] << " " <<endl;

    return 0;
}

#包括
使用名称空间std；
int main（）
{
int数组[8]={0,0,0,0,0,0,0,0}；
int min=数组[0]；
int max=数组[0]；
int indexOfMin=0；
int indexOfMax=0；
int arrSize=sizeof（数组）/sizeof（数组[0]）；
内部温度=0；
cout数组[k]；
}
对于（inti=0；i=max）{
max=数组[i]；
indexOfMax=i；
}
}
对于（inti=0；icout你已经有了找到最大值和最小值的索引。您还可以使用max和min。交换数组中的max和min值对于这些信息来说是微不足道的。使用：

array[indexofMin] = max;
array[indexOfMax] = min;

改进代码的建议：
1.修复访问阵列的问题
在循环之后读取数据

3.仅使用一个循环来计算最大值和最小值
交换
max
和
min
的值，但它们不会更改数组的内容

5.使用循环打印阵列
而不是

cout << array[k] << " " <<endl;

cout您已经有了找到最大值和最小值的索引。您还可以使用max和min。交换数组中的max和min值对于这些信息来说是微不足道的。使用：

array[indexofMin] = max;
array[indexOfMax] = min;

改进代码的建议：
1.修复访问阵列的问题
在循环之后读取数据

3.仅使用一个循环来计算最大值和最小值
交换
max
和
min
的值，但它们不会更改数组的内容

5.使用循环打印阵列
而不是

cout << array[k] << " " <<endl;

cout
你还不知道<代码>数组[0]
此时程序为
0
。。。但是
0
可能不是用户输入后数组的元素

内存中对象的索引和大小应为
std:：size\u t
（
）类型，因为可以保证
std:：size\u t
足够大。对于
int
，没有这样的保证

使用
std:：size（）
（
）可获得更清晰的代码：

auto const arrSize{ std::size(array) };

如果定义了
int min=数组[0]和
int max=array[0]
用户输入后，可以使用
i=1
启动这些循环。
if（array[i]==min）{continue；}
什么也买不到。相反，进行额外的比较会浪费时间。此外，两个回路可以组合为一个：

int min{ array[0] };
int max{ array[0] };

std::size_t indexOfMin{ 0 };
std::size_t indexOfMax{ 0 };

for (size_t i{ 1 }; i < arrSize; ++i) {
    if(array[i] < min) {
        min = array[i];
        indexOfMin = i;
    }
    else if(array[i] > max) {
        max = array[i];
        indexOfMax = i;
    }
}

将交换变量
min
和
max
的值。此外，如果可以通过这种方式交换数组中的最小值和最大值，为什么还要记住它们的位置？试一试

temp = array[indexOfMin];
array[indexOfMax] = array[indexOfMin];
array[indexOfMin = temp];

所以最后我就写了

for (k = 0; k <= 7; k++) {
    cout << array[k] << " " << endl;
}

（k=0；k）的

您还不知道。
array[0]
此时程序是
0
…但是
0
在用户输入后可能不是数组的元素

内存中对象的索引和大小应为
std:：size\u t
（
）类型，因为可以保证
std:：size\u t
足够大。对于
int
没有这样的保证

使用
std:：size（）
（
）可获得更清晰的代码：

auto const arrSize{ std::size(array) };

如果您定义了
int min=array[0]；
和
int max=array[0]；
在用户输入后，您可以使用
i=1
启动这些循环。如果（array[i]==min）{continue；}
不买任何东西。相反，它会浪费时间进行额外的比较。此外，两个循环可以组合成一个：

int min{ array[0] };
int max{ array[0] };

std::size_t indexOfMin{ 0 };
std::size_t indexOfMax{ 0 };

for (size_t i{ 1 }; i < arrSize; ++i) {
    if(array[i] < min) {
        min = array[i];
        indexOfMin = i;
    }
    else if(array[i] > max) {
        max = array[i];
        indexOfMax = i;
    }
}

将交换变量
min
和
max
的值。此外，如果可以通过这种方式交换数组中的最小值和最大值，为什么要记住它们的位置？请尝试

temp = array[indexOfMin];
array[indexOfMax] = array[indexOfMin];
array[indexOfMin = temp];

所以最后我就写了

for (k = 0; k <= 7; k++) {
    cout << array[k] << " " << endl;
}

for（k=0；k好吧，您有以下代码：

int min = array[0]; 
int max = array[0]; 

是的，这是将它们首先指向第一个元素的常用技术，但您需要使用实际值，而不是用于初始化数据的值。在数据集中（均为正值），您将始终具有
min==0
，并且
indexOfMin
始终指向0

问题是，实际上不需要为
min
和
max
保留值，因为索引已经足够了：

for (int i = 1; i < arrSize; i++) {
    if (array[indexOfMax] < array[i]) 
       indexOfMax = i;
    if (array[indexOfMin] > array[i]) 
       indexOfMin = i;

如果您不允许使用标准库，请使用temp。
好的，您有以下代码：

int min = array[0]; 
int max = array[0]; 

是的，这是将它们首先指向第一个元素的常用技术，但您需要使用实际值，而不是用于初始化数据的值。在数据集中（均为正值），您将始终具有
min==0
，并且
indexOfMin
始终指向0

问题是，实际上不需要为
min
和
max
保留值，因为索引已经足够了：

for (int i = 1; i < arrSize; i++) {
    if (array[indexOfMax] < array[i]) 
       indexOfMax = i;
    if (array[indexOfMin] > array[i]) 
       indexOfMin = i;

如果不允许使用标准库，则使用temp。
将
std:：swap
与从
std:：minmax_元素
返回的值结合使用
array[indexofMin]=max；
和
array[indexOfMax]=min；
。我想我最终已经做到了
cout@NathanOliver
std:：minmax_元素（）
返回迭代器，因此
std:：iter\u swap（）
比
std:：swap（）
：“交换给定迭代器指向的元素的值。”将
std:：swap
与从
std:：minmax\u元素
返回的值结合使用[indexOfMax]=min；
.I
for (k = 0; k <= 7; k++) {
    cout << array[k] << " " << endl;
}

for (std::size_t k = 0; k < arrSize; k++) {
    std::cout << array[k] << " ";
}
std::cout.put('\n');

int min = array[0]; 
int max = array[0]; 

for (int i = 1; i < arrSize; i++) {
    if (array[indexOfMax] < array[i]) 
       indexOfMax = i;
    if (array[indexOfMin] > array[i]) 
       indexOfMin = i;

std::swap( array[indexOfMax], array[indexOfMin] );