【NOI】C++数据结构入门之一维数组（二）数组找数

---

前言

在先前的学习中，我们奠定了坚实的基础，掌握了数组的基本操作，包括创建、访问、修改和遍历等。本篇内容将引领您进入数组处理的深层次领域，探讨如何在数组中查找特定值、确定数组中的最值（最大值和最小值）、统计某个元素在数组中的出现次数，以及确定元素的索引位置等操作。这不仅是算法竞赛如全国青少年信息学奥林匹克竞赛(NOI)的必备知识，也是解决现实世界复杂数据问题的利器。我们将通过实例分析，让抽象的概念生动起来，让您在编程之旅上更进一步。

学习路线：C++从入门到NOI学习路线

学习大纲：C++全国青少年信息学奥林匹克竞赛（NOI）入门级-大纲

---

一、概念

1.导入

在上一讲中，我们介绍了数组的创建和数组的使用（访问、修改、遍历）。

数组中有个重要的概念就是“索引”，无论是访问还是修改，以及更多更复杂的操作都是基于索引完成。

今天我们就需要索引来完成一个常见的操作——数组找数。

2.数组找数

数组找数问题通常指的是在给定的数组中寻找特定元素、满足一定条件的元素或执行某种操作的问题。这类问题可以包括但不限于以下几种情况：

1. 查找特定值：给定一个数组和一个目标值，判断目标值是否在数组中出现，或者返回其出现的位置。
2. 查找最值：找到数组中的最大值或最小值。
3. 统计出现次数：计算数组中某个元素出现的次数。
4. 查找索引：在数组中查找满足某个条件的数首次出现的位置或者最后出现的位置。

二、例题讲解

---

问题类型——查找特定值

给定一个数组和一个目标值，判断目标值是否在数组中出现，或者返回其出现的位置。

1. 解题方法一：使用布尔值标记

   通过变量bool f（find）来标记是否曾经找到过需要被查找的数x，初始值为false，表示没有找到，程序末尾如果f==true,说明找到该数。

2. 解题方法二：使用索引标记

   通过变量int idx（index）来标记需要被查找的数第一次出现的位置，初始值为-1，表示没有找到，程序末尾如果idx!=-1,说明找到该数。

并且如果是找某数x最后出现的位置，应优先考虑倒序查找。

---

问题：1154. 数组元素的查找

类型：数组找数

---

题目描述：

给你 m 个整数，查找其中有无值为 n 的数，有则输出该数第一次出现的位置,没有则输出 −1 。

输入：

第一行一个整数 m 代表数的个数 ( 0≤m≤100 ) 。

第二行 m 个整数（空格隔开）( 这些数在0∼1000000范围内 )。

第三行为要查找的数 n。

输出：

n 的位置或 −1。

样例：

输入：

4
1 2 3 3
3

输出：

3

---

1.分析问题

1. 已知： m 个整数 ( 0≤m≤100 );
2. 未知：查找其中有无值为 n 的数;
3. 关系：有则输出该数第一次出现的位置,没有则输出 -1 。

2.定义变量

• m: 存储数组中整数的数量。
• n: 需要查找的目标值。
• idx: 初始化为-1，用于记录目标值n第一次出现的位置。
• a[110]: 定义一个足够大的数组来存储输入的整数。

	//二、定义变量（已知、未知、关系） 
	int m,n,idx=-1,a[110];

3.输入数据

• 先输入整数的数量m，然后依次输入m个整数到数组a中，最后输入要查找的目标值n。

	//三、输入已知
	cin>>m;
	for(int i=1;i<=m;i++){
		cin>>a[i];
	}
	cin>>n;

4.数据计算

• 使用一个循环遍历数组a，比较每个元素是否等于目标值n。如果找到匹配项，则将当前索引i赋值给idx并退出循环。

	//四、根据关系计算
	for(int i=1;i<=m;i++){
		if(n==a[i]){
			idx=i;
			break;
		}
	}

5.输出结果

• 直接输出变量idx的值。如果找到了目标值，idx会被更新为其位置；否则，保持初始值-1，表示未找到。

	//五、输出未知 
	cout<<idx;

完整代码如下：

#include <bits/stdc++.h> // 引入常用头文件，包含了许多标准库函数
using namespace std;     // 使用std命名空间，避免std::前缀

int main() {
    // 一、问题分析
    // 给定m个整数构成的数组，以及一个目标值n，要求找出n在数组中首次出现的位置，若不存在则输出-1。
    
    int m, n, idx = -1; // 初始化变量
    int a[110];         // 定义足够大的数组来存放输入的整数序列
    
    // 三、输入数据
    cin >> m;            // 输入整数数量m
    for (int i = 1; i <= m; i++) {
        cin >> a[i];      // 输入m个整数到数组a中
    }
    cin >> n;            // 输入需要查找的目标值n
    
    // 四、查找目标值n在数组中的位置
    for (int i = 1; i <= m; i++) { // 遍历数组
        if (n == a[i]) {           // 如果当前元素等于目标值n
            idx = i;               // 记录该位置到idx
            break;                 // 找到后立即跳出循环
        }
    }
    
    // 五、输出结果
    cout << idx << endl; // 输出目标值n在数组中的位置，未找到则输出-1
    
    return 0; // 程序成功执行完毕，返回0
}

---

问题：1815. 最后一次出现该数的位置

类型：数组找数

---

题目描述：

从键盘输入一个整数 N ，输入 N (5≤N≤20)个元素，输入一个整数，判断这个数组中最后一次出现该数的位置，如果没有请输出−1。

输入：

第 1 行读入一个整数 n。（5≤n≤20）

第 2 行读入 n 个整数用空格隔开。

第 3 行读入 1 个整数，代表要找的数。

输出：

输出 1 个整数，代表最后一次出现整数的位置，如果数组中不存在这样的数，请输出 −1。

样例：

输入：

5
12 23 33 12 6
12

输出：

4

---

1.分析问题

1. 已知：n个整数 (5≤N≤20)，一个整数 m。
2. 未知：这个数组中最后一次出现该数的位置，如果没有请输出-1。
3. 关系：倒序查找

2.定义变量

• n: 存储数组的长度。
• a[25]: 存储整数的数组，大小为25以容纳最多20个整数及一些余量。
• m: 要查找的整数。
• ind: 初始化为-1，用于存储m在数组中最后一次出现的位置，如果未找到则保持为-1。

	//二、定义变量（已知、未知、关系）
	int n,a[25],m,ind=-1; 

3.输入数据

• 首先读取数组的长度n，然后通过循环读取n个整数到数组a中，接着读取要查找的整数m。

	//三、输入已知
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	cin>>m;

4.数据计算

• 从数组的末尾开始遍历（倒序查找），这样一旦找到m就会立刻停止搜索，提高了效率，尤其是当m靠近数组末尾时。

	//四、根据关系计算
	for(int i=n;i>=1;i--){
		if(m==a[i]){
			ind=i;
			break;
		}
	}

5.输出结果

• 输出变量ind，即m在数组中最后一次出现的位置，如果m不存在于数组中，则输出-1。

	//五、输出未知 
	cout<<ind;

完整代码如下：

#include <bits/stdc++.h> // 引入标准库中的所有常用头文件，简化编程时的头文件包含操作
using namespace std;     // 使用标准命名空间std，这样可以省略std::前缀直接调用库函数

int main() {
    // 一、问题分析
    // 给定条件：一个数组包含n（5到20之间）个整数，以及一个待查找的整数m。
    // 目标：找出m在数组中最后一次出现的位置，如果m不在数组中，则输出-1。
    // 策略：采用倒序遍历数组的方法，这样一旦找到m，即可立即返回其位置，提高效率。
    
    int n, a[25], m, ind = -1; // 定义变量
    // n：数组长度
    // a[25]：存储整数的数组，容量足够放下20个元素并留有余地
    // m：待查找的整数
    // ind：初始化为-1，用于记录m在数组中最后一次出现的位置，初始表示未找到

    // 三、输入数据
    cin >> n; // 输入数组长度
    for (int i = 1; i <= n; i++) {
        cin >> a[i]; // 输入数组中的每个整数
    }
    cin >> m; // 输入要查找的整数m

    // 四、查找过程
    // 从数组的末尾开始向前遍历，寻找m最后一次出现的位置
    for (int i = n; i >= 1; i--) { 
        if (m == a[i]) {
            ind = i; // 找到m，记录其位置并结束循环
            break;
        }
    }

    // 五、输出结果
    cout << ind; // 输出m在数组中的最后一次出现位置，如果没找到则输出初始值-1

    return 0; // 主函数正常结束，返回0
}

---

问题类型——查找最值

找到数组中的最大值或最小值。

1. 解题方法：打擂台

假设变量mmax是最大数，初始值为INT_MIN，循环后面所有的元素，如果有比假设的最大数还大的数，则替换最大数。

同理，假设变量mmin是最小数，初始值为INT_MAX，循环后面所有的元素，如果有比假设的最小数还小的数，则替换最小数。

---

问题：1152. 求n个数的最大值和最小值

类型：数组找数

---

题目描述：

任意输入 n 个整数，把它们的最大值，最小值求出来。

输入：

输入只有一行，包括一个整数 n (1≤n≤20),后面跟着 n 个数， 每个数的范围在0∼32767之间。

输出：

输出只有一行,包括 2 个整数。

样例：

输入：

5 1 99 3 6 0

输出：

99 0

---

1.分析问题

1. 已知：n 个整数(1≤n≤20);
2. 未知：输出它们的最大值，最小值;
3. 关系：打擂台 ；

2.定义变量

• n: 存储数组中整数的数量。
• a[22]: 定义一个足够大的数组来存储输入的n个整数。
• mmax: 初始化为INT_MIN，表示初始时认为的最大值。
• mmin: 初始化为INT_MAX，表示初始时认为的最小值。

	//二、定义变量（已知、未知、关系） 
	int n,a[22],mmax=INT_MIN,mmin=INT_MAX;

3.输入数据

• 首先读取整数n，然后通过一个循环读取n个整数到数组a中。

//三、输入已知
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
		
	}

4.数据计算

• 在读取每个整数的同时，将其与当前的mmax和mmin比较，如果当前整数更大，则更新mmax；如果更小，则更新mmin。这样的做法确保了只需遍历一次数组即可找到这两个值。

		//四、根据关系计算
		if(a[i]>mmax) mmax=a[i];
		if(a[i]<mmin) mmin=a[i];

5.输出结果

• 直接输出找到的最大值mmax和最小值mmin。

	//五、输出未知 
	cout<<mmax<<" "<<mmin;

完整代码如下：

#include <bits/stdc++.h> // 引入常用头文件，包含大量标准库功能
using namespace std;     // 使用std命名空间，简化代码中的标准库调用

int main() {
    // 一、问题分析
    // 给定一个包含n（1≤n≤20）个整数的数组，要求找出并输出其中的最大值和最小值。
    
    int n, a[22];          // n为数组长度，a[]用于存储数组元素
    int mmax = INT_MIN,    // 初始化最大值为整型最小值，确保任何输入值都能成为新最大值
         mmin = INT_MAX;   // 初始化最小值为整型最大值，确保任何输入值都能成为新最小值

    // 三、输入数组长度及元素
    cin >> n;              // 输入数组长度n
    for (int i = 0; i < n; i++) { // 循环读取n个整数
        cin >> a[i];       // 读取第i个整数
        
        // 四、打擂台法计算最大值和最小值
        // 比较并更新当前最大值和最小值
        if (a[i] > mmax) {
            mmax = a[i];   // 如果当前元素大于mmax，则更新mmax
        }
        if (a[i] < mmin) {
            mmin = a[i];   // 如果当前元素小于mmin，则更新mmin
        }
    }

    // 五、输出结果
    cout << mmax << " " << mmin << endl; // 输出数组中的最大值和最小值

    return 0; // 表示程序成功执行结束
}

---

问题：1168. 歌唱比赛评分

类型：数组找数

---

题目描述：

四（1） 班要举行一次歌唱比赛，以选拔更好的苗子参加校的歌唱比赛。评分办法如下：设 N 个评委，打 N 个分数（ 0≤每个分数≤10 ），去掉一个最高分，去掉一个最低分，剩下的评委的平均分即为该选手的最后得分。

但是选手太多了，靠人工计算每个选手的得分太慢太麻烦。你能不能帮帮他们，设计一个程序让计算机来算出选手的最后得分呢？

输入：

第一行为一个整数 N （5≤N≤10）；

第二行为 N 个整数 Ai （0≤Ai≤10 ）。

输出：

选手的最后得分（保留两位小数）。

样例：

输入：

5
5 6 7 8 9

输出：

7.00

---

1.分析问题

1. 已知：N 个分数(5≤N≤10);
2. 未知：该选手的最后得分（保留两位小数）。
3. 关系：去掉一个最高分，去掉一个最低分，剩下的评委的平均分即为该选手的最后得分。

2.定义变量

• n为评委数量，
• a[]数组存储每个评委的分数，
• mmax为最高分，
• mmin为最低分，
• r初始化总分为0，用于累加所有分数。

//二、定义变量（已知、未知、关系）
	int n,a[11],mmax=INT_MIN,mmin=INT_MAX; 
	double r=0.0;

3.输入数据

• 输入评委数量及各评委分数。
• 并找出最高分和最低分。

//三、输入已知
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
		r+=a[i];
		if(a[i]>mmax) mmax=a[i];
		if(a[i]<mmin) mmin=a[i];
	}

4.数据计算

• 去掉一个最高分和一个最低分，计算剩余分数的平均值。

//四、根据关系计算
	r=(r-mmax-mmin)/(n-2);

5.输出结果

• 输出最终得分。

//五、输出未知 
	cout<<fixed<<setprecision(2)<<r;

完整代码如下：

#include <bits/stdc++.h> // 引入常用的头文件，包含了很多标准库函数
using namespace std;     // 使用std命名空间，简化代码

int main() {
    // 一、问题分析
    // 已知：有N个评委的分数（5≤N≤10）；
    // 未知：去掉一个最高分和一个最低分后，剩余分数的平均值，即选手的最后得分（保留两位小数）。
    
    int n, a[11];          // n为评委数量，a[]数组存储每个评委的分数
    double r = 0.0;        // 初始化总分为0，用于累加所有分数
    int mmax = INT_MIN,    // 初始化最大分数为整型最小值，确保任何输入都是大值
         mmin = INT_MAX;   // 初始化最小分数为整型最大值，确保任何输入都是小值

    // 三、输入评委数量及各评委分数
    cin >> n;              // 输入评委数量n
    for (int i = 0; i < n; i++) {
        cin >> a[i];       // 输入第i个评委的分数
        r += a[i];         // 累加分数到总分r中
        // 同时更新最大值和最小值
        if (a[i] > mmax) mmax = a[i];
        if (a[i] < mmin) mmin = a[i];
    }

    // 四、根据规则计算最终得分
    // 去掉一个最高分和一个最低分，计算剩余分数的平均值
    r = (r - mmax - mmin) / (n - 2);

    // 五、输出最终得分，保留两位小数
    cout << fixed << setprecision(2) << r; // 使用fixed设置小数点后固定位数，setprecision设置精度为2位

    return 0; // 程序执行完毕，返回0表示成功
}

---

问题类型——统计出现次数

计算数组中某个元素出现的次数。

1. 解题方法：

   如果该数x是直接提供的，那么直接遍历整个数组，通过a[i]==x进行比较即可，满足则计数+1。

   如果该数x没有提供，而是满足某些条件，则需要先到数组中查找，再通过遍历比较。

---

问题：1810. 最贵商品和最便宜商品分别有几个

类型：数组找数

---

题目描述：

小明去超市买商品，买了 N 件，每件商品的价格都是整数（价格不会全都一样），小明想知道这 N 件商品中，最贵商品和最便宜商品分别有几个（最贵和最便宜分别可以有多个）？请你编写程序帮忙小明计算。

输入：

第 1 行有一个整数 n（n≤100）。

第 2 行有 n 个整数，用空格隔开。

输出：

输出 2 个整数，用空格隔开，第 1 个整数代表最贵的商品有几个，第 2 个整数代表最便宜的商品有几个。

样例：

输入：

6
12 3 3 15 34 17

输出：

1 2

---

1.分析问题

1. 已知：N （n≤100）件商品，每件商品的价格都是整数（价格不会全都一样）；

2. 未知：最贵商品和最便宜商品分别有几个；

2.定义变量

• n: 商品总数。
• a[110]: 存储每个商品的价格，数组大小足够大以容纳最多100件商品。
• mmax: 初始化为INT_MIN，用于存储遇到的最高价格。
• mmin: 初始化为INT_MAX，用于存储遇到的最低价格。
• cmax和cmin: 初始化为0，分别用于计数最高价和最低价商品的数量。

//二、定义变量（已知、未知、关系）
	int n,a[110],mmax=INT_MIN,mmin=INT_MAX,cmax=0,cmin=0; 

3.输入数据

• 首先接收商品的总数n，然后逐一输入每个商品的价格到数组a中。在输入过程中，同时更新最大值mmax和最小值mmin。

//三、输入已知
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
		if(a[i]>mmax) mmax=a[i];
		if(a[i]<mmin) mmin=a[i];
	}

4.数据计算

• 在所有商品价格都已知后，程序再次遍历数组，统计出最贵商品（价格等于mmax）和最便宜商品（价格等于mmin）的数量。

//四、根据关系计算
	for(int i=0;i<n;i++){
		if(a[i]==mmax) ++cmax;
		if(a[i]==mmin) ++cmin; 
	}

5.输出结果

• 最后，输出最贵商品的数量cmax和最便宜商品的数量cmin。

//五、输出未知 
	cout<<cmax<<" "<<cmin;

完整代码如下：

#include<bits/stdc++.h>
using namespace std;
int main(){
    // 一、分析问题
    // 已知：N 件商品的价格（n≤100），价格为整数且各不相同。
    // 未知：最贵商品和最便宜商品分别有几个。
    
    int n, a[110], mmax = INT_MIN, mmin = INT_MAX, cmax = 0, cmin = 0; 

    // 三、输入数据
    cin >> n; // 先输入商品总数n
    for(int i = 0; i < n; i++){
        cin >> a[i]; // 然后依次输入n个商品的价格
        // 在读取价格的同时，更新mmax和mmin
        if(a[i] > mmax) mmax = a[i];
        if(a[i] < mmin) mmin = a[i];
    }

    // 四、根据输入数据计算最贵和最便宜商品的数量
    //已知所有商品价格后，再统计最贵和最便宜商品的数量
    for(int i = 0; i < n; i++){
        if(a[i] == mmax) ++cmax; // 如果当前价格等于目前的最大价格，最贵商品计数加1
        if(a[i] == mmin) ++cmin; // 如果当前价格等于目前的最小价格，最便宜商品计数加1
    }

    // 五、输出未知
    cout << cmax << " " << cmin; // 输出最贵和最便宜商品的数量

    return 0;
}

---

问题类型——查找索引

在数组中查找满足某个条件的数首次出现的位置或者最后出现的位置。

1. 解题方法：

   查找满足某些条件的数x的位置，则需要到数组中查找出满足条件的数x，注意这里并不只是记录该数x，还要记录x的索引。

   并且如果是找某数x最后出现的位置，应优先考虑倒序查找。

---

问题：1428. 找同学的位置

类型：数组找数

---

题目描述：

有一个班的同学在操场上排好了队，老师想知道这些同学中学号最大的同学和学号最小的同学所在的位置。

请你编程帮老师找出来。

输入：

第 1 行是一个整数 n ，代表排队的同学的数量（ n≤100 ）。

第 2 行是 n 个整数，代表 n 个同学的学号（不存在重复的学号）。

输出：

输出 1行，包含 2 个整数，第一个整数代表学号最大的同学的位置，第二个整数代表学号最小的同学的位置。

样例：

输入：

6
1 8 9 10 5 3

输出：

4 1

---

1.分析问题

1. 已知：n个排队的同学（ n≤100 ）。
2. 未知：学号最大的同学和学号最小的同学所在的位置。
3. 关系：

2.定义变量

• n: 学生总数。
• a[110]: 存储每个学生的学号。
• mmax: 初始化为INT_MIN，用来记录当前遇到的最大学号。
• mmin: 初始化为INT_MAX，用来记录当前遇到的最小学号。
• imax和imin: 分别记录最大学号和最小学号对应的学生在队列中的位置（序号）。

//二、定义变量（已知、未知、关系） 
	int n,a[110],mmax=INT_MIN,mmin=INT_MAX,imax,imin;

3.输入数据

• 读取学生总数n，然后通过循环读取每个学生的学号到数组a中。

	//三、输入已知
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		
	}

4.数据计算

• 同时，在读取过程中实时更新mmax、mmin以及对应的序号imax和imin。

		//四、根据关系计算
		if(a[i]>mmax){
			mmax=a[i];
			imax=i;
		}
		if(a[i]<mmin){
			mmin=a[i];
			imin=i;
		}

5.输出结果

• 根据计算，直接输出学号最大和最小的学生在队列中的位置（序号）。

	//五、输出未知 
	cout<<imax<<" "<<imin;

完整代码如下：

#include<bits/stdc++.h>
using namespace std;

int main(){
    // 一、问题分析
    // 已知：有一队列包含n名同学（队列长度限制为n≤100），
    // 每名同学有一个独一无二的学号，学号为整数。
    // 未知：需要找出学号最大和学号最小的同学在队列中的位置（按排队顺序）。
    
    // 二、定义变量
    int n;                  // n表示学生总数
    int a[110];             // a数组用于存储每个学生的学号
    int mmax = INT_MIN;     // 初始化最大学号为整型最小值，确保任何输入的学号都能覆盖
    int mmin = INT_MAX;     // 初始化最小学号为整型最大值，同样确保覆盖所有可能的输入
    int imax, imin;         // imax和imin分别存储学号最大和最小学生的队列位置

    // 三、输入学生总数
    cin >> n;
    
    // 四、输入每个学生的学号，并同时寻找学号最大和最小的学生及其位置
    for(int i = 1; i <= n; i++){ // 从数组下标1开始，符合题目描述
        cin >> a[i];              // 输入第i个学生的学号
        
        // 检查当前学生学号与当前已知的最大/最小学号比较
        if(a[i] > mmax){          // 如果当前学号大于已知最大学号
            mmax = a[i];          // 更新最大学号
            imax = i;             // 记录最大学号对应的学生位置
        }
        if(a[i] < mmin){          // 如果当前学号小于已知最小学号
            mmin = a[i];          // 更新最小学号
            imin = i;             // 记录最小学号对应的学生位置
        }
    }

    // 五、输出结果
    // 输出学号最大和学号最小的学生在队列中的位置
    cout << imax << " " << imin;
    
    return 0; // 程序执行完毕，正常退出
}

---

问题：1212. 移动数组元素

类型：数组找数

---

题目描述：

在一个不重复的数组中，请将这个数组的最小数和数组第一个数交换，最大数和数组最后一个数交换。

输入：

第一行有一个整数 n ( 5≤n≤100 ）；

第二行有 n 个不重复的整数。

输出：

移动位置后的数组。

样例：

输入：

5
6 7 1 10 4

输出：

1 7 6 4 10

---

1.分析问题

1. 已知：一个不重复的数组 ( 5≤ai≤100 ）。
2. 未知：输出交换后的数组。
3. 关系：最小数和数组第一个数交换，最大数和数组最后一个数交换。

2.定义变量

• n: 存储数组的长度。
• a[110]: 数组，用于存放输入的整数序列，数组大小足够存储题目要求的最大元素数量。
• mmax和mmin: 初始化为整型的最大值和最小值，分别用于记录遍历过程中遇到的最大值和最小值。
• imax和imin: 记录最大值和最小值在数组中的索引。

	//二、定义变量（已知、未知、关系） 
	int n,a[110],mmax=INT_MIN,mmin=INT_MAX,imax,imin;

3.输入数据

• 通过标准输入获取数组长度n，然后遍历数组，读取每个元素的值，并在此过程中更新mmax、mmin、imax、和imin。

	//三、输入已知
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
		
		if(a[i]>mmax){
			mmax=a[i];
			imax=i;
		}
		if(a[i]<mmin){
			mmin=a[i];
			imin=i;
		}
	}

4.数据计算

• 使用swap函数，分别交换数组的第一个元素与最小值所在位置的元素，以及数组的最后一个元素与最大值所在位置的元素。

	//四、根据关系计算
	swap(a[0],a[imin]);
	swap(a[n-1],a[imax]);

5.输出结果

• 遍历交换后的数组，将每个元素输出，元素间以空格分隔。

	//五、输出未知 
	for(int i=0;i<n;i++){
		cout<<a[i]<<" ";
	} 

完整代码如下：

#include <bits/stdc++.h> // 引入标准库中的所有常用头文件
using namespace std;     // 使用std命名空间，简化代码中的库函数调用

int main() {
    // 一、问题分析
    // 给定条件：数组长度至少为5，至多为100，且数组中的元素各不相同。
    // 目标：交换数组中的最小元素与首元素，最大元素与末尾元素，然后输出交换后的数组。
    
    int n, a[110], mmax = INT_MIN, mmin = INT_MAX, imax, imin;
    // 变量定义：n为数组长度，a[]为数组，mmax和mmin用于记录当前最大值和最小值，imax和imin记录它们的索引。
    
    // 三、输入数组信息
    cin >> n; // 输入数组长度
    for(int i = 0; i < n; i++) {
        cin >> a[i]; // 逐一输入数组元素
        // 同时寻找最大值和最小值及其索引
        if(a[i] > mmax) {
            mmax = a[i];
            imax = i;
        }
        if(a[i] < mmin) {
            mmin = a[i];
            imin = i;
        }
    }
    
    // 四、根据条件交换元素
    swap(a[0], a[imin]); // 将最小值与数组首元素交换
    swap(a[n-1], a[imax]); // 将最大值与数组末尾元素交换
    
    // 五、输出交换后的数组
    for(int i = 0; i < n; i++) {
        cout << a[i] << " "; // 依次输出数组元素
    }
    
    return 0; // 程序执行完毕，返回0表示成功
}

---

三、总结

经过本章节的深入探索，我们已经跨越了从基础到进阶的一维数组应用边界，深刻理解了如何在数组中高效地“找数”。从简单的查找特定值，到复杂度更高的最值判定、元素频次统计，乃至精确索引的定位，每一步都凝聚了算法思维的精髓。通过实战演练，我们不仅巩固了基础，还解锁了处理数组数据的新视角，为解决更广泛问题打下了坚实基础。

我们见证了“打擂台法”在快速求最值中的高效应用，体会了统计元素出现次数的巧妙逻辑，以及如何利用索引标记快速定位元素位置。这些技巧不仅提升了编程效率，更锻炼了逻辑推理与问题解决的能力。记住，每一次的实践都是向卓越编程迈进的坚实步伐。未来，无论是面对NOI的挑战，还是日常编程任务，您都将更加游刃有余。

四、感谢

如若本文对您的学习或工作有所启发和帮助，恳请您给予宝贵的支持——轻轻一点，为文章点赞；若觉得内容值得分享给更多朋友，欢迎转发扩散；若认为此篇内容具有长期参考价值，敬请收藏以便随时查阅。

每一次您的点赞、分享与收藏，都是对我持续创作和分享的热情鼓励，也是推动我不断提供更多高质量内容的动力源泉。期待我们在下一篇文章中再次相遇，共同攀登知识的高峰！