实验6数组-四川大学
数组及应用实验报告
一、实验目的1. 理解数组的定义和概念，掌握数组的声明、初始化和访问方法。
2. 掌握一维数组和二维数组的操作，包括元素的赋值、排序、查找等。
3. 熟悉数组在实际编程中的应用，如排序算法、查找算法等。
4. 培养解决实际问题的能力，提高编程水平。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 语言：C/C++三、实验内容1. 一维数组的声明、初始化和访问2. 一维数组的排序（冒泡排序、选择排序、插入排序）3. 一维数组的查找（线性查找、二分查找）4. 二维数组的声明、初始化和访问5. 二维数组的操作（求和、求平均值、查找最大值和最小值）6. 数组在实际编程中的应用（如冒泡排序算法实现、字符串匹配）四、实验步骤1. 一维数组的声明、初始化和访问（1）声明一个整型一维数组，如int arr[10];（2）初始化数组，如arr[0] = 1, arr[1] = 2, ...;（3）访问数组元素，如printf("%d", arr[i]);2. 一维数组的排序（1）冒泡排序：比较相邻元素，如果逆序则交换，重复执行，直到排序完成。
（2）选择排序：每次选择未排序部分的最小（或最大）元素，放到已排序部分的末尾。
（3）插入排序：将未排序的元素插入到已排序部分的合适位置。
3. 一维数组的查找（1）线性查找：逐个比较数组元素，找到目标元素则返回其位置。
（2）二分查找：在有序数组中，先确定中间元素，再与目标元素比较，根据比较结果缩小查找范围。
4. 二维数组的声明、初始化和访问（1）声明一个整型二维数组，如int arr[3][4];（2）初始化数组，如arr[0][0] = 1, arr[0][1] = 2, ...;（3）访问数组元素，如printf("%d", arr[i][j]);5. 二维数组的操作（1）求和：遍历二维数组，将所有元素相加。
数组实验报告结果
一、实验目的1. 理解数组的概念和基本操作。
2. 掌握数组的创建、初始化、赋值、遍历、查找、排序等基本操作。
3. 培养动手实践能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容本次实验主要对数组进行以下操作：1. 创建数组2. 初始化数组3. 赋值操作4. 遍历数组5. 查找操作6. 排序操作四、实验步骤1. 创建数组```javaint[] array = new int[10]; // 创建一个长度为10的整型数组```2. 初始化数组```javaint[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 创建并初始化一个长度为10的整型数组```3. 赋值操作```javaarray[0] = 10; // 将数组第一个元素的值赋为10```4. 遍历数组```javafor (int i = 0; i < array.length; i++) {System.out.println(array[i]); // 遍历数组并打印每个元素的值}```5. 查找操作```javaint target = 5; // 查找目标值int index = -1; // 存储目标值在数组中的索引for (int i = 0; i < array.length; i++) {if (array[i] == target) {index = i;break;}}if (index != -1) {System.out.println("找到目标值：" + target + "，索引为：" + index); } else {System.out.println("未找到目标值：" + target);}```6. 排序操作```javaint[] array = {5, 3, 8, 2, 1};for (int i = 0; i < array.length - 1; i++) {for (int j = 0; j < array.length - 1 - i; j++) {if (array[j] > array[j + 1]) {int temp = array[j];array[j] = array[j + 1];array[j + 1] = temp;}}}System.out.println("排序后的数组：");for (int i = 0; i < array.length; i++) {System.out.print(array[i] + " ");}```五、实验结果与分析1. 创建数组：成功创建了一个长度为10的整型数组。
数组实验报告结果讨论(3篇)
第1篇一、实验背景随着计算机技术的飞速发展，数组作为数据结构中的重要组成部分，在计算机科学和实际应用中扮演着至关重要的角色。
本实验旨在通过一系列的数组操作，验证数组的基本性质，探讨数组在实际应用中的优势与局限性，并分析实验结果。
二、实验目的1. 熟悉数组的基本操作，如初始化、赋值、遍历、插入、删除、查找等；2. 掌握数组的动态分配和释放；3. 分析数组在实际应用中的性能特点；4. 探讨数组在处理大数据时的优势与局限性。
三、实验内容本次实验主要进行了以下内容：1. 初始化数组并赋值；2. 遍历数组并输出元素；3. 在数组中插入元素；4. 在数组中删除元素；5. 在数组中查找元素；6. 动态分配和释放数组空间；7. 分析数组在实际应用中的性能特点。
四、实验结果及讨论1. 初始化数组并赋值实验结果：通过初始化数组并赋值，我们成功创建了所需的数组，并对其进行了赋值操作。
讨论：初始化数组是使用数组的前提，赋值操作则可以确保数组中存储的数据符合预期。
在本次实验中，我们使用了静态数组初始化和动态数组初始化两种方法，发现动态数组初始化在空间利用率上具有优势。
2. 遍历数组并输出元素实验结果：成功遍历数组，并输出数组中的所有元素。
讨论：遍历数组是数组操作中最基本、最常用的操作之一。
在本实验中，我们使用了for循环和while循环两种方式遍历数组，发现两种方式在性能上没有明显差异。
在实际应用中，应根据具体情况选择合适的遍历方式。
3. 在数组中插入元素实验结果：成功在数组中插入元素，并保持数组的连续性。
讨论：在数组中插入元素时，需要考虑数组容量是否足够。
如果数组已满，则需要重新分配空间，这将增加额外的开销。
在本次实验中，我们使用了动态数组来插入元素，提高了空间的利用率。
4. 在数组中删除元素实验结果：成功在数组中删除元素，并保持数组的连续性。
讨论：删除数组元素时，需要注意删除操作可能会影响数组的连续性。
在本次实验中，我们通过将删除元素后的后续元素前移来保持数组的连续性。
数组实验报告的总结
一、实验背景随着计算机科学的不断发展，数组作为一种基本的数据结构，在编程中得到了广泛的应用。
为了更好地理解数组的原理和特性，我们进行了数组实验，通过实际操作和理论分析，加深对数组概念的理解。
二、实验目的1. 理解数组的定义、特点和应用场景；2. 掌握数组的创建、访问、修改和删除等基本操作；3. 分析数组在编程中的优势与不足，提高编程能力。
三、实验内容1. 数组的定义与特点数组是一种有序集合，用于存储具有相同数据类型的元素。
数组的元素在内存中连续存放，通过索引访问元素。
数组具有以下特点：（1）元素类型相同：数组中所有元素的数据类型必须相同；（2）连续存储：数组元素在内存中连续存放，便于提高访问速度；（3）索引访问：通过索引快速访问数组元素；（4）动态创建：根据需要动态创建数组，节省内存空间。
2. 数组的创建与初始化在Java中，创建数组主要有以下两种方式：（1）声明数组：int[] array = new int[10]; // 创建一个长度为10的整型数组（2）声明并初始化：int[] array = {1, 2, 3, 4, 5}; // 创建并初始化一个包含5个整数的数组3. 数组的基本操作（1）访问元素：通过索引访问数组元素，如array[0]表示访问第一个元素；（2）修改元素：直接通过索引修改数组元素，如array[1] = 10;；（3）删除元素：在Java中，无法直接删除数组元素，但可以通过重新排序或覆盖元素来实现；（4）查找元素：通过遍历数组，比较元素值，找到目标元素。
4. 数组的应用实例（1）冒泡排序：通过比较相邻元素的大小，实现数组的升序排序；（2）查找算法：如二分查找、线性查找等，通过遍历数组，找到目标元素；（3）动态规划：利用数组存储中间结果，实现复杂问题的求解。
四、实验结果与分析1. 通过实验，我们掌握了数组的定义、特点和应用场景，加深了对数组概念的理解；2. 实验过程中，我们学会了创建、访问、修改和删除数组元素等基本操作，提高了编程能力；3. 在实际应用中，数组在排序、查找、动态规划等方面具有广泛的应用，为编程提供了便利。
C语言实验报告《数组》
C语言实验报告《数组》《数组》实验报告实验目的：掌握C语言中数组的定义、初始化和使用方法，了解数组在程序中的作用和用途，熟悉数组的基本操作。
实验内容：1.数组的定义和初始化2.数组的基本操作-访问数组元素-修改数组元素-遍历数组-数组作为函数参数实验步骤：1.数组的定义和初始化定义一个整型数组，数组名为array，数组大小为10。
使用for循环将数组元素初始化为0。
2.数组的基本操作1) 访问数组元素：通过下标访问数组的元素，例如array[0]表示数组的第一个元素。
2)修改数组元素：通过下标将数组的元素修改为新的值。
3) 遍历数组：使用for循环遍历数组的每个元素，并输出其值。
4)数组作为函数参数：将数组作为函数的参数传递，并在函数内对数组进行操作。
实验结果：1.数组的定义和初始化：int array[10];for (int i = 0; i < 10; i++)array[i] = 0;}2.数组的基本操作：1)访问数组元素：int x = array[0]; // 访问第一个元素的值，即数组的第一个元素2)修改数组元素：array[0] = 1; // 将第一个元素的值修改为13)遍历数组：for (int i = 0; i < 10; i++)printf("%d ", array[i]); // 输出每个元素的值}4)数组作为函数参数：void printArray(int arr[], int len)for (int i = 0; i < len; i++)printf("%d ", arr[i]); // 输出数组的每个元素}}int maiint myArray[5] = {1, 2, 3, 4, 5};printArray(myArray, 5); // 将数组myArray作为参数传递给printArray函数return 0;}实验总结：通过本次实验，我们掌握了C语言中数组的定义和初始化方法，学会了访问数组元素、修改数组元素、遍历数组的操作，还了解了数组作为函数参数的使用。
数组的实验报告结论(3篇)
第1篇一、实验目的本次实验旨在通过一系列的数组操作，验证数组的定义、创建、赋值、遍历、排序、查找等基本操作，掌握数组在实际编程中的应用，提高编程能力。
二、实验内容1. 数组的定义与创建通过定义数组变量，并使用不同的方式创建数组，如使用{}直接创建、使用new创建等，验证了数组的创建方法。
2. 数组的赋值通过给数组元素赋值，观察数组的实际内容，验证了数组的赋值操作。
3. 数组的遍历通过for循环、增强型for循环、foreach循环等不同方式遍历数组，验证了数组的遍历方法。
4. 数组的排序通过冒泡排序、选择排序、插入排序等算法对数组进行排序，验证了数组的排序操作。
5. 数组的查找通过顺序查找、二分查找等算法对数组进行查找，验证了数组的查找操作。
三、实验结果与分析1. 数组的定义与创建实验结果显示，通过定义数组变量，并使用不同的方式创建数组，均能成功创建数组。
在实际编程中，应根据具体需求选择合适的创建方式。
2. 数组的赋值实验结果显示，给数组元素赋值后，数组的内容发生了变化，验证了数组的赋值操作。
3. 数组的遍历实验结果显示，通过不同的遍历方式，均能成功遍历数组。
在实际编程中，应根据具体需求选择合适的遍历方式。
4. 数组的排序实验结果显示，通过冒泡排序、选择排序、插入排序等算法对数组进行排序，均能成功实现数组的排序。
在实际编程中，应根据具体需求选择合适的排序算法。
5. 数组的查找实验结果显示，通过顺序查找、二分查找等算法对数组进行查找，均能成功实现数组的查找。
在实际编程中，应根据具体需求选择合适的查找算法。
四、实验结论1. 数组是实际编程中常用的一种数据结构，具有丰富的操作方法。
2. 掌握数组的定义、创建、赋值、遍历、排序、查找等基本操作，有助于提高编程能力。
3. 在实际编程中，应根据具体需求选择合适的数组创建、遍历、排序、查找等方法，以提高编程效率和代码质量。
4. 本实验为后续学习其他数据结构和算法奠定了基础，有助于提高编程水平。
实验数组的实验报告
一、实验目的1. 掌握数组的基本概念和操作方法。
2. 熟悉C语言中数组的定义、初始化、赋值和引用。
3. 学会使用数组和循环结构进行数据处理。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C语言三、实验内容1. 定义和初始化一维数组2. 访问和修改数组元素3. 使用数组进行数据处理4. 定义和初始化二维数组5. 访问和修改二维数组元素6. 使用二维数组进行数据处理7. 使用数组进行排序和查找四、实验步骤1. 定义和初始化一维数组```c#include <stdio.h>int main() {int array[5] = {1, 2, 3, 4, 5};int i;// 循环访问数组元素for (i = 0; i < 5; i++) {printf("array[%d] = %d\n", i, array[i]); }return 0;}```2. 访问和修改数组元素```c#include <stdio.h>int main() {int array[5] = {1, 2, 3, 4, 5};int i;// 修改数组元素array[2] = 10;// 循环访问数组元素for (i = 0; i < 5; i++) {printf("array[%d] = %d\n", i, array[i]); }return 0;}```3. 使用数组进行数据处理```c#include <stdio.h>int main() {int array[5] = {1, 2, 3, 4, 5}; int i, sum = 0;// 计算数组元素之和for (i = 0; i < 5; i++) {sum += array[i];}printf("sum = %d\n", sum);return 0;}```4. 定义和初始化二维数组```c#include <stdio.h>int main() {int array[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int i, j;// 循环访问二维数组元素for (i = 0; i < 3; i++) {for (j = 0; j < 3; j++) {printf("array[%d][%d] = %d\n", i, j, array[i][j]); }}return 0;}```5. 访问和修改二维数组元素```c#include <stdio.h>int main() {int array[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int i, j;// 修改二维数组元素array[1][1] = 10;// 循环访问二维数组元素for (i = 0; i < 3; i++) {for (j = 0; j < 3; j++) {printf("array[%d][%d] = %d\n", i, j, array[i][j]); }}return 0;}```6. 使用二维数组进行数据处理```c#include <stdio.h>int main() {int array[3][3] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int i, j, sum = 0;// 计算二维数组元素之和for (i = 0; i < 3; i++) {for (j = 0; j < 3; j++) {sum += array[i][j];}}printf("sum = %d\n", sum);return 0;}```7. 使用数组进行排序和查找```c#include <stdio.h>// 交换两个元素void swap(int a, int b) {int temp = a;a = b;b = temp;}// 冒泡排序void bubbleSort(int array[], int length) {int i, j;for (i = 0; i < length - 1; i++) {for (j = 0; j < length - 1 - i; j++) { if (array[j] > array[j + 1]) {swap(&array[j], &array[j + 1]); }}}}// 查找元素int findElement(int array[], int length, int target) { int i;for (i = 0; i < length; i++) {if (array[i] == target) {return i;}}return -1;}int main() {int array[5] = {5, 2, 8, 3, 1};int i, index;// 冒泡排序bubbleSort(array, 5);// 输出排序后的数组for (i = 0; i < 5; i++) {printf("%d ", array[i]);}printf("\n");// 查找元素index = findElement(array, 5, 8);if (index != -1) {printf("Element 8 found at index %d\n", index);} else {printf("Element 8 not found\n");}return 0;}```五、实验结果与分析1. 通过定义和初始化一维数组，可以方便地存储和管理一系列具有相同数据类型的元素。
关于数组实验报告总结
一、实验目的1. 熟悉数组的基本概念和操作方法。
2. 掌握数组的初始化、赋值、遍历、排序、查找等基本操作。
3. 培养编程思维和解决问题的能力。
二、实验内容本次实验主要围绕数组展开，包括以下内容：1. 数组的定义与初始化2. 数组元素的赋值与遍历3. 数组的插入与删除4. 数组的排序5. 数组的查找三、实验步骤1. 数组的定义与初始化（1）定义一个整型数组，命名为arr，大小为10。
（2）使用循环初始化数组元素，从0到9。
2. 数组元素的赋值与遍历（1）使用循环遍历数组，打印出每个元素的值。
（2）将数组的第5个元素赋值为20。
3. 数组的插入与删除（1）在数组的第3个位置插入一个新元素，值为15。
（2）删除数组的第6个元素。
4. 数组的排序（1）使用冒泡排序算法对数组进行排序。
（2）使用选择排序算法对数组进行排序。
5. 数组的查找（1）使用线性查找算法查找数组中值为15的元素。
（2）使用二分查找算法查找数组中值为15的元素。
四、实验结果与分析1. 数组的定义与初始化实验结果：成功定义了一个大小为10的整型数组arr，并使用循环初始化了数组元素。
分析：通过定义数组并初始化，我们可以存储一组有序或无序的数据，方便后续操作。
2. 数组元素的赋值与遍历实验结果：成功遍历了数组，并修改了数组的第5个元素。
分析：通过赋值和遍历操作，我们可以对数组元素进行修改和查询，满足实际应用需求。
3. 数组的插入与删除实验结果：成功在数组中插入了一个新元素，并删除了指定位置的元素。
分析：插入和删除操作可以改变数组的大小和元素顺序，满足实际应用场景。
4. 数组的排序实验结果：使用冒泡排序和选择排序算法对数组进行了排序。
分析：排序操作可以使数组元素按照特定顺序排列，便于后续查找和操作。
5. 数组的查找实验结果：使用线性查找和二分查找算法成功找到了数组中值为15的元素。
分析：查找操作可以快速定位到指定元素的位置，提高程序效率。
五、实验总结通过本次实验，我们掌握了数组的基本概念和操作方法，包括定义、初始化、赋值、遍历、插入、删除、排序和查找等。
最新《实验二：数组》实验报告
最新《实验二：数组》实验报告实验目的：1. 掌握数组的基本概念和使用方法。
2. 理解数组在内存中的存储方式。
3. 学会使用循环结构对数组进行遍历和操作。
4. 培养解决实际问题时数组应用的能力。
实验环境：- 操作系统：Windows 10- 开发工具：Visual Studio 2019- 编程语言：C++实验内容：1. 创建一个整型数组，包含10个元素，初始化为0到9的整数。
2. 使用循环结构实现数组中所有元素的累加，并输出结果。
3. 编写一个函数，计算数组中所有偶数的和，并返回结果。
4. 实现一个功能，允许用户输入一个整数，将其插入到数组的指定位置。
5. 对数组进行排序，使用冒泡排序算法，并输出排序后的数组。
实验步骤：1. 定义一个整型数组arr[10]，并初始化。
2. 使用for循环，遍历数组，计算累加和，并输出。
3. 定义一个函数int calculateEvenSum(int arr[], int size)，接收数组和数组大小作为参数，计算偶数和。
4. 实现用户输入功能，通过scanf获取用户输入的整数和指定位置，调用一个函数void insertElement(int arr[], int size, int value, int position)进行插入。
5. 应用冒泡排序算法对数组进行排序，定义一个函数voidbubbleSort(int arr[], int size)实现排序，并输出排序后的结果。
实验结果：1. 初始数组：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}。
2. 数组累加和输出：45。
3. 偶数和输出：20。
4. 用户输入插入操作：假设用户输入的值为5，指定位置为3，插入后的数组：{0, 1, 5, 2, 3, 4, 5, 6, 7, 8, 9}。
5. 排序后的数组输出：{0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9}。
实验分析：通过本次实验，我们成功实现了数组的基本操作，包括初始化、遍历、插入、计算和排序。
数组实验报告实验分析
一、实验目的1. 理解数组的概念和基本操作。
2. 掌握数组的创建、初始化、访问和修改方法。
3. 学习数组的排序、查找和统计等常用算法。
4. 分析数组在实际应用中的优缺点。
二、实验内容1. 数组的创建与初始化2. 数组元素的访问与修改3. 数组的排序4. 数组的查找5. 数组的统计6. 数组在实际应用中的优缺点分析三、实验过程1. 数组的创建与初始化在实验中，我们首先学习了如何创建一个数组。
在C语言中，可以使用以下语句创建一个整型数组：int arr[10];这里创建了一个包含10个整数的数组，名称为arr。
接下来，我们学习了如何初始化数组。
初始化可以通过以下语句实现：int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};这里初始化了一个包含10个整数的数组，并将前10个整数依次赋值给数组元素。
2. 数组元素的访问与修改访问数组元素可以通过以下语句实现：int value = arr[3]; // 获取数组第4个元素的值修改数组元素可以通过以下语句实现：arr[5] = 20; // 将数组第6个元素的值修改为203. 数组的排序在实验中，我们学习了冒泡排序算法。
冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻的元素，将较大的元素交换到数组的后面。
以下是冒泡排序算法的C语言实现：void bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}4. 数组的查找在实验中，我们学习了二分查找算法。
二分查找算法是一种高效的查找算法，其基本思想是将查找区间分为两半，每次查找时缩小查找范围。
数组实验报告范文
数组实验报告范文实验报告标题：数组操作实验摘要：本实验通过对数组的基本操作实例进行实践，探讨了数组的定义、初始化、元素赋值、元素访问、元素修改和数组长度等操作的方法和注意事项。
1.引言数组是一种常见的数据结构，其在计算机科学和编程中有着广泛的应用。
通过对数组的操作，可以实现数组元素的存储、访问和修改等功能。
在本次实验中，我们将通过实践操作来掌握数组的基本操作方法。
2.实验目的1)掌握数组的定义和初始化方法；2)熟悉数组元素的赋值、访问和修改；3)了解数组的长度属性及其用法。
3.实验内容3.1数组的定义和初始化在编程语言中，数组的定义和初始化可以分为静态数组和动态数组两种方式。
静态数组的定义方式为：类型[数组长度] 数组名；例如：int numArr[5];静态数组的初始化方式有两种：-一种是在定义时进行初始化，即直接在数组定义中指定数组的初始值；-另一种是在定义后通过循环结构对数组进行逐元素赋值的方式进行初始化。
动态数组的定义和初始化方式与静态数组有所不同，需要调用相应的分配内存函数进行动态内存的分配。
3.2数组元素的赋值、访问和修改数组元素的赋值即将一些值赋给数组的一个或多个元素。
通过下标索引的方式可以访问和修改数组中的元素。
例如，定义了一个长度为5的整型数组numArr，可以通过numArr[0]、numArr[1]、numArr[2]、numArr[3]和numArr[4]来访问和修改数组中的元素。
3.3数组的长度属性及其用法数组的长度属性即数组的元素个数，可以通过数组的长度属性来获取数组的长度。
例如，使用int length = numArr.length;就可以获取数组numArr的长度。
4.实验步骤4.1数组的定义和初始化首先，我们定义了一个整型数组numArr，并在定义时进行了初始化。
int[] numArr = {1, 2, 3, 4, 5};然后，我们使用循环结构对数组进行逐元素赋值的方式进行初始化。
数组应用实验报告
数组应用实验报告
《数组应用实验报告》
在计算机科学领域，数组是一种非常重要的数据结构，它可以存储多个相同类型的数据，方便进行管理和操作。
在本次实验中，我们将探讨数组的应用，并通过实验报告来展示其在不同场景下的使用情况。
实验一：数组的创建和初始化
在本实验中，我们首先学习了如何创建和初始化数组。
通过编写简单的代码，我们成功创建了一个包含整数类型的数组，并对其进行了初始化。
我们发现，数组的索引是从0开始的，这意味着我们可以通过索引来访问数组中的元素。
实验二：数组的遍历和操作
接下来，我们学习了如何遍历数组并对其进行操作。
我们使用循环结构来遍历数组中的每个元素，并进行相应的操作。
我们发现，使用数组可以方便地对一组数据进行统一的处理，比如求和、平均值等操作。
实验三：多维数组的应用
在这个实验中，我们学习了多维数组的应用。
通过创建二维数组，我们可以模拟二维空间中的数据结构，比如矩阵、图像等。
我们发现，多维数组可以方便地表示复杂的数据结构，并且可以通过多重循环来对其进行遍历和操作。
实验四：数组的应用案例
最后，我们通过实际案例来展示数组的应用。
我们使用数组来实现一个简单的学生成绩管理系统，通过输入学生的成绩，然后计算平均分、最高分、最低分等统计数据。
我们发现，数组的使用大大简化了数据的管理和操作，提高了程序的效率和可维护性。
综上所述，本次实验通过实验报告展示了数组在不同场景下的应用情况。
通过学习和实践，我们深刻理解了数组的重要性和灵活性，相信在今后的编程工作中，我们将能够更加熟练地运用数组来解决实际问题。
C语言实验报告 实验六 参考答案
实验六二维数值数组（参考答案）(1) 设计程序sy6-1.c，从键盘上输入一个3行3列矩阵各个元素的值，输出其主对角线元素和反向对角线元素之和。
算法分析：方阵主对角线上的元素，行下标和列下标相同；辅对角线元素，如果行下标为i，列下标就为2-i；参考答案：# include <stdio.h># include <stdlib.h># include <math.h># include <time.h>void main(){int a[3][3];int i,j,sum=0;srand( time( NULL ) );printf("矩阵：\n");for(i=0;i<3;i++) //用随机函数生成3行3列的二维数组并按矩阵格式输出{for(j=0;j<3;j++){a[i][j]=rand()%20;printf("%4d",a[i][j]);}printf("\n");}for(i=0;i<3;i++)sum=sum+a[i][i]+a[i][2-i];printf("该矩阵的正、反对角线元素之和为：%d\n",sum);}运行结果：(2) 设计程序sy6-2.c，找出N×N矩阵中每列元素中的最大值，并按顺序依次存放于b数组中。
算法分析：按列序遍历二维数组，每列用打擂台的方法求最大数，N列则有N个最大值，分别存于b数组的对应元素中。
# include <stdio.h># include <stdlib.h># include <math.h># include <time.h># define N 4void main(){int a[N][N],b[N];int i,j;srand( time( NULL ) );printf("矩阵：\n");for(i=0;i<N;i++) //用随机函数生成N行N列的二维数组并按矩阵格式输出{for(j=0;j<N;j++){a[i][j]=rand()%20;printf("%4d",a[i][j]);}printf("\n");}for(j=0;j<N;j++) //外循环控制列下标{b[j]=a[0][j]; //假设每列的0行元素是最大数for(i=1;i<N;i++)if(b[j]<a[i][j])b[j]=a[i][j];}printf("该矩阵每列元素的最大值是：\n");for(i=0;i<N;i++)printf("%4d",b[i]);printf("\n");}运行结果：(3) 设计程序sy6-3.c，定义一个3×3的二维数组，通过随机函数自动赋值。
数组及其应用实验报告(3篇)
第1篇一、实验目的1. 熟练掌握数组的定义、初始化、赋值和输入输出方法。
2. 掌握一维数组和二维数组的操作方法。
3. 学会使用数组进行数据存储和排序。
4. 理解数组在实际编程中的应用场景。
二、实验环境硬件：个人电脑软件：Windows操作系统、C语言编译器三、实验内容1. 一维数组的定义、初始化和赋值2. 一维数组的输入输出3. 一维数组的查找与排序4. 二维数组的定义、初始化和赋值5. 二维数组的输入输出6. 二维数组的遍历7. 数组在实际编程中的应用案例四、实验步骤1. 一维数组的定义、初始化和赋值```cinclude <stdio.h>int main() {int array[5]; // 定义一个包含5个整数的数组array[0] = 1; // 赋值操作array[1] = 2;array[2] = 3;array[3] = 4;array[4] = 5;return 0;}```2. 一维数组的输入输出```cinclude <stdio.h>int main() {int array[5];printf("请输入5个整数：\n"); for (int i = 0; i < 5; i++) { scanf("%d", &array[i]);}printf("输入的数组元素为：\n"); for (int i = 0; i < 5; i++) { printf("%d ", array[i]);}return 0;}```3. 一维数组的查找与排序```cinclude <stdio.h>void selectionSort(int array[], int length) {for (int i = 0; i < length - 1; i++) {int minIndex = i;for (int j = i + 1; j < length; j++) {if (array[j] < array[minIndex]) {minIndex = j;}}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}}int main() {int array[5] = {3, 1, 4, 1, 5};int length = sizeof(array) / sizeof(array[0]); selectionSort(array, length);printf("排序后的数组为：\n");for (int i = 0; i < length; i++) {printf("%d ", array[i]);}return 0;}```4. 二维数组的定义、初始化和赋值```cinclude <stdio.h>int main() {int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; return 0;}```5. 二维数组的输入输出```cinclude <stdio.h>int main() {int array[3][4];printf("请输入一个3x4的二维数组：\n");for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {scanf("%d", &array[i][j]);}}printf("输入的二维数组为：\n");for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {printf("%d ", array[i][j]);}printf("\n");}return 0;}```6. 二维数组的遍历```cinclude <stdio.h>int main() {int array[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; for (int i = 0; i < 3; i++) {for (int j = 0; j < 4; j++) {printf("%d ", array[i][j]);}printf("\n");}return 0;}```7. 数组在实际编程中的应用案例（1）计算矩阵的转置```cinclude <stdio.h>void transposeMatrix(int matrix[][3], int rows, int cols, int transposed[][3]) {for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {transposed[j][i] = matrix[i][j];}}}int main() {int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};int rows = 3, cols = 3, transposed[3][3];transposeMatrix(matrix, rows, cols, transposed);printf("矩阵的转置为：\n");for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {printf("%d ", transposed[i][j]);}printf("\n");}return 0;}```（2）计算数组中最大值和最小值```cinclude <stdio.h>void findMaxMin(int array[], int length, int max, int min) { max = array[0];min = array[0];for (int i = 1; i < length; i++) {if (array[i] > max) {max = array[i];}if (array[i] < min) {min = array[i];}}}int main() {int array[] = {1, 3, 5, 7, 9};int length = sizeof(array) / sizeof(array[0]);int max, min;findMaxMin(array, length, &max, &min);printf("数组中的最大值为：%d，最小值为：%d\n", max, min);return 0;}```五、实验结果及分析本次实验通过一系列的实例，使我们对数组及其应用有了更深入的了解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验6 数组一、实验目的1. 理解一维数组的基本概念2. 掌握一维数组的定义、初始化、数组元素的引用3. 掌握一维数组的输入、输出等基本操作4. 掌握字符数组的使用5. 掌握一维数组的有关算法的思路和实现，如冒泡法与选择法排序、数组逆置以及数组元素的查询与插入等常用算法。
二、实验内容实训1 有10位学生的成绩存放在数组score中，从键盘输入1个数，查找这个成绩是否在数组中，如果在，输出其下标，如果不在，输出0。
数组的下标i表示第i位学生的成绩，数组的下标0处不存储成绩。
实验步骤：1) 在VS2008中新建项目，在项目中新建C++源文件，输入下面程序，并且编译、连接。
//***************************************************************//* 程序名：实训1.cpp *//* 主要功能： *//* 使用顺序查找法查找学生成绩单 *//* 从最后一位学生到第一位学生依次进行比较，以下标0为监视哨 *//***************************************************************#include <iostream> // 包含输入输出接口文件using namespace std; // 引用标准命名空间int main() // 主函数{const int n = 10; // 使用常变量定义学生人数int score[n + 1] = {0, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98};// 定义成绩数组，有n+1个整型元素，其中下标0处未存放学生成绩16 int i; // 循环变量int x; // 等查找的学生成绩cout<<"请输入待查找的学生成绩：";cin>>x;score[0] = x; // 在下标处设置监视哨21 for(i = n; score[i] != x; i--);// 计数循环，从后到前循环比较当前元素，循环体为空语句if(i >= 1){cout<<"查找成功，待查找成绩是第"<<i<<" 位学生的成绩"<<endl;}else{cout<<"未查找到该成绩！"<<endl;}return 0;}2) 运行实训1，待查找成绩分别输入为70、75、80、85、90，观察输出结果。
3) 快速查看数组score中每个元素的值。
提示：（1）利用Watch窗口查看数组a. 在第16行int i;处设置一个普通断点；b. 按F5开始调试c. 在左下方的监视窗口中输入数组变量名score，即可显示score的信息，将其展开，就可以查看score的每个元素。
其好处是比较清晰，有数组下标和值的对应显示，但数组规模较大时不方便。
（2）一次查看更多数组元素值在上述监视窗口中，不仅能看到数组的值，还能得到score的首地址，这样就能利用VS2008的查看内存功能查看数组元素的值。
按Alt+6，在弹出的内存窗口的地址编辑框中输入刚才查到的score首地址，按回车，即可发现数组score的所有元素均显示在窗口，如图6-1所示。
图6-1 以16进制数方式显示的内存窗口但它们是以16进制方式显示的，看起来不太方便，可在内存窗口中点击鼠标右键，在弹出的右键菜单中选择“4字节整数”及“不带符号显示”，如图6-2所示，然后内存窗口就将以十进制数值方式显示内容的值，如图6-3所示。
图6-2 内存窗口右键菜单图6-3 以十进制数方式显示的内存窗口4) 在第12行for语句处设置断点，当输入数据分别为70、75、80、85、90时，分别观察第12行for语句的执行次数。
实训2在用户名和密码的存储中，我们一般使用明文保存用户名，使用密文保存密码。
在用户登录界面中，用户输入的是用户名和密码的明文，要检查用户名、密码是否正确，需将密码密文转换为明文，然后再与输入的密码进行比较。
本例程序用于将教材例4.4得到的密码密文转换为密码明文，以便进行后继处理。
提示：本例首先从键盘输入密码密文，再依次将密文的各字符按规律转换即可。
要将密文的一个字符ch进行转换，首先需得到密文字符ch的序号，如ch为小写字母，则其序号为“ch- 'a'+1”；如为大写字母，则为“ch- 'A'+27”。
然后依照规则将密文序号转为明文序号。
当得到明文字符的序号num后，如其值在1～26之间，则相应的字符的ASCII码值为num+'a'-1，如果值在27～52之间，则为num-27+'A'。
将密文的字符依次按上述规律转换便可得到明文,最后需为明文字符串加上结束标志。
参考程序如下：//***************************************************************//* 程序名：实训2.cpp *//* 主要功能： *//* 密码文本加密 *//* 使用移位加密法，密文序号为明文序号乘3 *//***************************************************************#include <iostream> // 包含输入输出接口文件#include <string.h> // 包含字符串相关函数定义的头文件using namespace std; // 引用标准命名空间int main() // 主函数{char password[20] = ""; // 存储密码的字符数组14 char encodePass[20] = ""; // 加密后的密码char ch; // 当前字符int i; // 循环变量int n; // 密码字符串长度int num; // 字符cout<<"密码：";cin>>password;n = strlen(password); // 获取密码长度for(i = 0; i < n; i++) // 计数循环，对密码字符依次进行处理{ch = password[i];if(ch >= 'a' && ch <= 'z'){ // 小写字母num = ch - 'a' + 1; // 计算字母序号}else if(ch >= 'A' && ch <= 'Z'){ // 大字字母num = ch - 'A' + 27; // 计算字母序号}else{encodePass[i] = ch; // 其它字符，直接复制continue; // 直接转向处理下一字符}num = num * 3 % 52; // 密文字母序号if(num == 0) // 处理字符Z{num = 52;}if(num <= 26){ch = 'a' + num - 1; // 将密文序号转为小写字母}else{ch = 'A' + num -27; // 将密文序号转为大写字母}encodePass[i] = ch; // 将密文字符存储到密文字符数组中}53 encodePass[i] = '\0'; // 为密文字符串加上结束标记cout<<"加密后的密码为："<<encodePass<<endl;return 0;}实验步骤：1) 在VS2008中新建项目，在项目中新建C++源文件，输入上面程序，并且编译、连接。
2) 运行实训2，输入密文字符串iSkPhbw：，观察输出的明文字符串。
3) 在所有的字母字符中，哪一个字符的明文字符和密文字符是相同的？4) 将第14行改为：char encodePass[20];，即不对其进行初始化，然后编译运行，输入iSkPhbw 后观察输出的明文字符串。
5) 继续步骤4)，去掉程序的第53行，依然输入密文字符串iSkPhbw，观察输出的明文字符串，观察其与第4)结果的异同，并分析为什么会这样。
实训3从键盘输入10位学生的身高，然后使用简单选择法按低到高的顺序进行排序。
提示：选择排序是不断在待排序序列（无序区）中按递增（或递减）次序选择记录，放入有序区中，逐渐扩大有序区，直到整个记录区为有序区为止。
其基本思想是：每一趟（例如第i 趟，i = 1，2，…n-1）在后面n-i 个待排序对象中选出最小的一个,作为有序序列的第i 个（即与原来数组的第i个元素进行交换）。
待到第n-1 趟排完后, 待排序对象只剩下1个，就不用再选了。
实训4 编写程序接受用户输入的一行字符（不超过80字符），将其中的大写字母转换为小写字母，小写字母转换为大写字母，其余类型的字符一律不变，然后按输入顺序的逆序输出。
如输入为“I am a student2”，则输出为“i AM A STUDENT2”。
提示：使用gets_s()将一行字符读入到字符数组中，然后对字符数组进行循环，在循环中判定字符是否为字母。
若是，则将大写字母转换为小写、小写字母转换为大写，并写加到字符数组中。
最后使用strlen()求得字符数组中最后一个字符的位置，从字符数组的最后一个字符向前依次输出即可。
三、实验报告要求1. 根据程序要求对运行结果进行分析。
如果程序未能调试通过，分析其原因。
2. 根据实验步骤，说明未能编译通过的原因，并正确进行修改。
3. 总结实验中遇到的问题，理解C语言数组的使用方法，并谈谈本次实验的收获与经验。
4. 在问题描述项中使用NS图描述各实训算法。
5. 实验报告内容及评分标准参见实验1。
6. 实验报告必须于11月23日（第12周周一）前提交至课程中心。