C 语言中的数组操作

CCBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

在本实验中,你将学习如何在 C 编程中处理数组。实验涵盖了数组声明、初始化、访问和迭代的基本概念。你将从介绍数组声明语法开始,然后继续学习如何使用值初始化整数数组,使用索引访问数组元素,最后在 for 循环中打印元素。通过本实验,你将掌握在 C 语言中使用数组的扎实基础。


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/BasicsGroup(["Basics"]) c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c/BasicsGroup -.-> c/variables("Variables") c/BasicsGroup -.-> c/data_types("Data Types") c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/variables -.-> lab-438330{{"C 语言中的数组操作"}} c/data_types -.-> lab-438330{{"C 语言中的数组操作"}} c/for_loop -.-> lab-438330{{"C 语言中的数组操作"}} c/arrays -.-> lab-438330{{"C 语言中的数组操作"}} c/output -.-> lab-438330{{"C 语言中的数组操作"}} end

介绍数组声明语法

在这一步中,我们将介绍 C 编程中数组声明的基本概念。数组是一种重要的数据结构,它允许你在连续的内存位置中存储多个相同类型的元素。可以将数组想象成一排存储箱,每个箱子可以存放特定类型的物品,你可以通过唯一的索引号访问这些箱子。

什么是数组?

数组是一个通过索引号访问的变量集合。数组中的所有元素都是相同类型的。想象一个书架,每个书架可以存放同一类别的书籍——这与编程中数组的工作原理类似。每本“书”(或元素)都可以通过其在书架上的位置(索引)来访问。

数组声明语法

在 C 语言中,声明数组的语法如下:

type arrayName[arraySize];
  • type:数组中元素的数据类型(例如 intfloatchar)。这决定了数组可以存储的数据类型。
  • arrayName:数组的名称,你将使用它来引用和操作数组。
  • arraySize:数组可以容纳的元素数量,定义了数组的总存储容量。

示例:声明和初始化数组

让我们通过在 WebIDE 中创建一个新文件来探索数组声明。这个实际示例将帮助你理解数组在真实编程场景中的工作原理。

打开 WebIDE 并按照以下步骤操作:

  1. 在文件资源管理器中右键单击并选择“新建文件”。
  2. 将文件命名为 arrays_intro.c
  3. 单击文件以在编辑器中打开它。

现在,让我们编写一个简单的程序来演示数组的声明和初始化:

#include <stdio.h>

int main() {
    // 声明一个包含 5 个元素的整数数组
    int numbers[5] = {10, 20, 30, 40, 50};

    // 打印数组元素
    printf("Array elements:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

让我们分解数组声明:

  • int numbers[5]:这声明了一个名为 numbers 的整数数组,可以容纳 5 个元素。就像创建一个有 5 个空间的架子来存储整数值。
  • {10, 20, 30, 40, 50}:这用特定值初始化数组,用预定的数字填充每个“架子空间”。
  • 第一个元素 numbers[0] 是 10,第二个 numbers[1] 是 20,依此类推。请记住,在 C 语言中,数组索引从 0 开始。

编译并运行程序:

要在终端中编译和运行程序,请使用以下命令:

gcc arrays_intro.c -o arrays_intro
./arrays_intro

示例输出:

Array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

此输出展示了如何使用索引访问和打印数组中的每个元素。理解这一基本概念是掌握 C 编程中数组操作的第一步。

使用值初始化整数数组

在这一步中,我们将探索在 C 编程中初始化整数数组的不同方法。理解数组初始化对于高效处理数据集合至关重要。

打开 WebIDE 并创建一个新文件:

  1. 在文件资源管理器中右键单击并选择“新建文件”。
  2. 将文件命名为 array_initialization.c
  3. 单击文件以在编辑器中打开它。

在 C 语言中使用数组时,你会很快发现初始化数组有多种方法。每种方法都有其特定的使用场景,可以帮助你高效地设置数据存储。让我们深入了解这些初始化技术,并理解它们的工作原理:

#include <stdio.h>

int main() {
    // 方法 1:完全初始化
    int scores[5] = {85, 92, 78, 90, 88};

    // 方法 2:部分初始化(剩余元素设置为 0)
    int temperatures[5] = {72, 75, 80};

    // 方法 3:将所有元素初始化为零
    int ages[5] = {0};

    // 打印数组
    printf("Scores array:\n");
    for (int i = 0; i < 5; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
    }

    printf("\nTemperatures array:\n");
    for (int i = 0; i < 5; i++) {
        printf("temperatures[%d] = %d\n", i, temperatures[i]);
    }

    printf("\nAges array:\n");
    for (int i = 0; i < 5; i++) {
        printf("ages[%d] = %d\n", i, ages[i]);
    }

    return 0;
}

当你运行这段代码时,你将看到不同的初始化方法在实际中的效果。代码展示了三种主要的创建和填充数组的方式,每种方式在编程中都有不同的用途。

编译并运行程序:

gcc array_initialization.c -o array_initialization
./array_initialization

示例输出:

Scores array:
scores[0] = 85
scores[1] = 92
scores[2] = 78
scores[3] = 90
scores[4] = 88

Temperatures array:
temperatures[0] = 72
temperatures[1] = 75
temperatures[2] = 80
temperatures[3] = 0
temperatures[4] = 0

Ages array:
ages[0] = 0
ages[1] = 0
ages[2] = 0
ages[3] = 0
ages[4] = 0

让我们分解每个初学者都应该理解的数组初始化关键概念,重点关注代码:

  • 方法 1:完全初始化 int scores[5] = {85, 92, 78, 90, 88};:这里我们声明了一个名为 scores 的大小为 5 的数组,并用 5 个特定值初始化它。这是在声明时为数组的每个位置分配特定值的直接方法。数组的每个元素都按照花括号内值的顺序设置。
  • 方法 2:部分初始化 int temperatures[5] = {72, 75, 80};:在这种情况下,大小为 5 的 temperatures 数组仅用三个值初始化。C 语言通过将剩余元素(索引 3 和 4)设置为零来处理这种情况。部分初始化在你只知道前几个值并希望其余值默认为零时非常有用。
  • 方法 3:将所有元素初始化为零 int ages[5] = {0};:这将一个名为 ages 的大小为 5 的数组初始化为所有元素为零。如果你需要数组中的所有值都从零开始,这是一个方便的快捷方式。这在计数或数据结构的初始状态等情况下非常常见。
  • 数组大小在声明时固定:重要的是要记住,一旦你声明了一个特定大小的数组(例如 [5]),这个大小以后就不能更改。你不能在不创建新数组的情况下添加或删除元素。
  • 索引始终从 0 开始:正如你已经看到的,数组元素通过索引访问,这些索引始终从 0 开始表示第一个元素。在 scores 数组中,scores[0] 表示第一个元素,scores[1] 表示第二个元素,依此类推。

这些初始化方法为你设置和使用数组提供了灵活性。随着你在 C 编程中的进步,你会发现这些技术对于高效且清晰地管理数据集合非常宝贵。

使用索引访问数组元素

在 C 语言中,数组是从零开始索引的,这意味着第一个元素位于索引 0,第二个位于索引 1,依此类推。这个概念一开始可能看起来有些反直觉,但它是许多编程语言中的标准约定,源于低级内存管理。

打开 WebIDE 并创建一个新文件:

  1. 在文件资源管理器中右键单击并选择“新建文件”。
  2. 将文件命名为 array_indexing.c
  3. 单击文件以在编辑器中打开它。

让我们编写一个程序来演示数组索引和操作:

#include <stdio.h>

int main() {
    // 声明并初始化一个学生成绩数组
    int grades[5] = {85, 92, 78, 90, 88};

    // 访问单个数组元素
    printf("First grade (index 0): %d\n", grades[0]);
    printf("Third grade (index 2): %d\n", grades[2]);

    // 修改数组元素
    printf("\nBefore modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // 修改特定元素
    grades[1] = 95;  // 更改第二个成绩
    grades[4] = 87;  // 更改最后一个成绩

    printf("\nAfter modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // 计算平均成绩
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += grades[i];
    }
    float average = (float)total / 5;
    printf("\nAverage grade: %.2f\n", average);

    return 0;
}

在这个示例中,我们使用了一个学生成绩数组。代码展示了每个初学者都应该理解的几个重要数组操作。我们首先声明了一个包含五个整数元素的数组,表示不同的学生成绩。

编译并运行程序:

gcc array_indexing.c -o array_indexing
./array_indexing

示例输出:

First grade (index 0): 85
Third grade (index 2): 78

Before modification:
grades[0] = 85
grades[1] = 92
grades[2] = 78
grades[3] = 90
grades[4] = 88

After modification:
grades[0] = 85
grades[1] = 95
grades[2] = 78
grades[3] = 90
grades[4] = 87

Average grade: 87.00

输出展示了如何访问特定的数组元素、打印它们的值并修改它们。for 循环展示了一种高效遍历所有数组元素的方法,这在处理任何大小的数组时都至关重要。

关于数组索引的关键点,重点关注以下代码行:

  • 数组索引从 0 开始:数组 grades 中的第一个元素使用 grades[0] 访问,而不是 grades[1]printf 语句 printf("First grade (index 0): %d\n", grades[0]); 展示了这一关键概念。
  • 使用 array[index] 访问单个元素:语句 printf("Third grade (index 2): %d\n", grades[2]); 展示了如何访问给定索引处的特定元素。在这里,我们访问的是索引 2 处的第三个元素。
  • 通过赋值修改数组元素:代码行 grades[1] = 95;grades[4] = 87; 展示了如何更改数组中存储的值。索引 1 处的值更新为 95,索引 4 处的值更新为 87。这是通过索引和赋值运算符直接访问和修改的。
  • 注意不要访问数组边界之外的索引:如果你尝试访问 grades[5](记住数组有 5 个元素,索引从 0 到 4),很可能会导致错误(这称为“缓冲区溢出”或“越界访问”)。访问不存在的索引会导致不可预测的行为。
  • 使用循环高效遍历数组元素for 循环(例如用于打印数组的循环)是一种从索引 04 顺序遍历数组中每个元素的高效方法:
for (int i = 0; i < 5; i++) {
    printf("grades[%d] = %d\n", i, grades[i]);
}

这个循环使用变量 i 作为从 04 的索引。

理解这些原则将帮助你在 C 编程中有效地操作数组。练习和实验是掌握数组操作的关键。

在 for 循环中打印元素

当你刚开始学习编程时,循环的概念可能会让人感到畏惧。然而,它们是非常强大的工具,能够让你高效且优雅地执行重复任务。for 循环提供了一种结构化的方式来遍历数组元素,让你能够精确控制与每个元素的交互。

打开 WebIDE 并创建一个新文件:

  1. 在文件资源管理器中右键单击并选择“新建文件”。
  2. 将文件命名为 array_loop_print.c
  3. 单击文件以在编辑器中打开它。

让我们编写一个程序来演示打印数组元素的不同方法:

#include <stdio.h>

int main() {
    // 声明并初始化一个温度数组
    int temperatures[5] = {72, 75, 80, 68, 85};

    // 方法 1:使用带索引的标准 for 循环
    printf("Method 1: Printing with index\n");
    for (int i = 0; i < 5; i++) {
        printf("Temperature %d: %d degrees\n", i + 1, temperatures[i]);
    }

    // 方法 2:使用描述性标签打印数组
    printf("\nMethod 2: Printing with labels\n");
    char *days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
    for (int i = 0; i < 5; i++) {
        printf("%s's temperature: %d degrees\n", days[i], temperatures[i]);
    }

    // 方法 3:计算并打印附加信息
    printf("\nMethod 3: Calculating average temperature\n");
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += temperatures[i];
        printf("Adding %d degrees\n", temperatures[i]);
    }
    float average = (float)total / 5;
    printf("Average temperature: %.1f degrees\n", average);

    return 0;
}

在这个示例中,我们不仅仅是打印数组元素,还展示了循环的多样性。每种方法都展示了处理数组的不同方式,帮助你理解 for 循环在 C 编程中的灵活性。

编译并运行程序:

gcc array_loop_print.c -o array_loop_print
./array_loop_print

示例输出:

Method 1: Printing with index
Temperature 1: 72 degrees
Temperature 2: 75 degrees
Temperature 3: 80 degrees
Temperature 4: 68 degrees
Temperature 5: 85 degrees

Method 2: Printing with labels
Monday's temperature: 72 degrees
Tuesday's temperature: 75 degrees
Wednesday's temperature: 80 degrees
Thursday's temperature: 68 degrees
Friday's temperature: 85 degrees

Method 3: Calculating average temperature
Adding 72 degrees
Adding 75 degrees
Adding 80 degrees
Adding 68 degrees
Adding 85 degrees
Average temperature: 76.0 degrees

关于 for 循环和数组的关键点,重点关注以下代码:

  • 循环变量 i 从 0 开始,直到 array_length - 1:方法 1 中的标准循环初始化 for (int i = 0; i < 5; i++) 确保循环从数组 temperatures 的第一个元素(索引 0)迭代到最后一个元素(索引 4),并打印每个元素。条件 i < 5 决定了循环的持续时间。
  • 你可以使用循环索引访问数组元素:在 for 循环中,temperatures[i] 用于在每次循环周期中访问索引 i 处的元素。这展示了循环计数器如何作为数组索引使用。
  • 循环非常适合对整个数组执行操作:方法 3 展示了如何使用 for 循环计算总和并在循环期间打印附加信息。for 循环用于遍历所有数组元素并计算 total
  • 你可以将循环与计算和其他数组结合使用:方法 2 将 for 循环与额外的 days 数组结合使用,而方法 3 在循环期间进行计算。这展示了如何将数组和循环结合使用。

理解这些概念将帮助你编写更高效和可读性更强的代码。随着你在编程中的进步,你会发现循环和数组是解决复杂问题和实现复杂算法的重要工具。

高级数组操作

在这一步中,我们将探索一些可以对数组执行的高级操作,例如查找最大值和最小值,以及对数组进行排序。这些技术对于数据分析、处理和算法实现至关重要。

让我们编写一个程序来查找数组中的最大值和最小值:

cd ~/project
touch find_max_min.c
#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int max = numbers[0];
    int min = numbers[0];

    for (int i = 1; i < 5; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
        if (numbers[i] < min) {
            min = numbers[i];
        }
    }

    printf("Maximum value: %d\n", max);
    printf("Minimum value: %d\n", min);

    return 0;
}

这段代码展示了一种简单而强大的技术,用于查找数组中的最大值和最小值。通过将 maxmin 初始化为数组的第一个元素,然后比较每个后续元素,我们可以高效地识别数组中的极值。

关键代码行:

  • 初始化: int max = numbers[0]; int min = numbers[0]; - maxmin 变量被初始化为数组的第一个元素。这一步为比较提供了起点。
  • 比较循环: for (int i = 1; i < 5; i++) - 这个 for 循环从索引 1(第二个元素)开始,直到数组的末尾。这确保每个后续值都与当前的 maxmin 值进行比较。
  • 查找最大值: if (numbers[i] > max) { max = numbers[i]; } - 这个代码块检查当前元素是否大于当前的 max。如果为真,则将 max 变量更新为当前元素的值。
  • 查找最小值: if (numbers[i] < min) { min = numbers[i]; } - 类似地,这检查当前元素是否小于当前的 min,并在找到更小的值时更新 min

接下来,让我们编写一个程序,使用冒泡排序算法对数组进行升序排序:

cd ~/project
touch bubble_sort.c
#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int numbers[5] = {50, 20, 30, 10, 40};

    bubbleSort(numbers, 5);

    printf("Sorted array:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

冒泡排序是一种经典的排序算法,它反复遍历列表,比较相邻元素,并在顺序错误时交换它们。虽然对于大型数据集来说,它不是最高效的排序方法,但它为排序概念和数组操作提供了极好的入门。

关键代码行:

  • 外层循环: for (int i = 0; i < n-1; i++) - 这个外层循环控制遍历数组的次数。循环运行 n-1 次(其中 n 是数组的大小),因为每次遍历后,最大的元素都会到达其最终位置。
  • 内层循环: for (int j = 0; j < n-i-1; j++) - 内层循环执行实际的比较和交换。随着最大的元素“冒泡”到末尾,内层循环的范围会减小,这就是为什么我们使用 n - i - 1 而不是 n
  • 比较: if (arr[j] > arr[j+1]) - 这个语句检查当前元素是否大于下一个元素。
  • 交换: 代码行 int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp;arr[j] 大于 arr[j+1] 时执行两个元素的交换。使用临时变量 temp 来避免在交换过程中丢失一个值。

要编译并运行这些程序,请在终端中使用以下命令:

gcc find_max_min.c -o find_max_min
./find_max_min

gcc bubble_sort.c -o bubble_sort
./bubble_sort

查找最大值和最小值的示例输出:

Maximum value: 50
Minimum value: 10

排序的示例输出:

Sorted array:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

这些示例展示了 C 编程中构成更复杂数据处理技术基础的基本数组操作。

总结

在本实验中,我们学习了 C 编程中数组声明和初始化的基本概念。我们探索了声明整数数组的语法,包括如何使用特定值初始化数组。我们还学习了如何使用索引访问数组的单个元素,以及如何在 for 循环中打印数组元素。最后,我们探索了一些高级数组操作,例如查找最大值和最小值,以及使用冒泡排序算法对数组进行排序。这些技能对于处理数组至关重要,而数组是 C 编程中的关键数据结构。