programming

C语言数组基础

数组是C语言中用于存储多个相同类型数据的数据结构。它将多个元素按顺序存储在连续的内存空间中，通过索引来访问各个元素。数组是编程中最基础也是最重要的数据结构之一，掌握数组的使用对于处理批量数据和实现复杂算法至关重要。

数组的基本概念

什么是数组

数组是一组具有相同数据类型的元素的集合，这些元素：

  • 存储在连续的内存位置
  • 通过索引（下标）来访问
  • 索引从0开始
  • 数组大小在声明时确定

数组的优势

  1. 批量存储：可以存储大量相同类型的数据
  2. 随机访问：通过索引可以快速访问任意元素
  3. 内存效率：元素连续存储，内存使用效率高
  4. 循环处理：便于使用循环进行批量操作

一维数组

数组的声明和初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>

int main() {
    // 声明数组
    int numbers[5];  // 声明一个包含5个整数的数组
    
    // 声明并初始化
    int scores[5] = {85, 92, 78, 96, 88};
    
    // 部分初始化（其余元素自动设为0）
    int grades[10] = {90, 85, 78};  // 前3个元素有值，其余为0
    
    // 自动确定数组大小
    int values[] = {1, 2, 3, 4, 5};  // 编译器自动确定大小为5
    
    // 全部初始化为0
    int zeros[5] = {0};  // 或者 int zeros[5] = {};
    
    printf("scores数组：");
    for (int i = 0; i < 5; i++) {
        printf("%d ", scores[i]);
    }
    printf("\n");
    
    printf("grades数组：");
    for (int i = 0; i < 10; i++) {
        printf("%d ", grades[i]);
    }
    printf("\n");
    
    return 0;
}

数组元素的访问和修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 访问数组元素
    printf("第一个元素：%d\n", numbers[0]);
    printf("第三个元素：%d\n", numbers[2]);
    printf("最后一个元素：%d\n", numbers[4]);
    
    // 修改数组元素
    numbers[1] = 25;
    numbers[3] = 45;
    
    printf("\n修改后的数组：");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 使用变量作为索引
    int index = 2;
    printf("\n索引%d的元素：%d\n", index, numbers[index]);
    
    return 0;
}

数组的输入和输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>

int main() {
    int size = 5;
    int numbers[size];
    
    // 输入数组元素
    printf("请输入%d个整数：\n", size);
    for (int i = 0; i < size; i++) {
        printf("第%d个数：", i + 1);
        scanf("%d", &numbers[i]);
    }
    
    // 输出数组元素
    printf("\n你输入的数组：");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 计算数组统计信息
    int sum = 0;
    int max = numbers[0];
    int min = numbers[0];
    
    for (int i = 0; i < size; i++) {
        sum += numbers[i];
        if (numbers[i] > max) max = numbers[i];
        if (numbers[i] < min) min = numbers[i];
    }
    
    printf("\n统计信息：\n");
    printf("总和：%d\n", sum);
    printf("平均值：%.2f\n", (float)sum / size);
    printf("最大值：%d\n", max);
    printf("最小值：%d\n", min);
    
    return 0;
}

字符数组和字符串

字符数组的基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <string.h>

int main() {
    // 字符数组的不同初始化方式
    char str1[10] = {'H', 'e', 'l', 'l', 'o', '\0'};  // 手动添加结束符
    char str2[10] = "Hello";    // 自动添加结束符
    char str3[] = "World";     // 自动确定大小
    char str4[20];             // 未初始化
    
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    printf("str3: %s\n", str3);
    
    // 字符串输入
    printf("请输入一个字符串：");
    scanf("%s", str4);  // 注意：scanf不能读取包含空格的字符串
    printf("你输入的字符串：%s\n", str4);
    
    // 使用fgets读取包含空格的字符串
    char sentence[100];
    printf("请输入一句话：");
    getchar();  // 清除缓冲区中的换行符
    fgets(sentence, sizeof(sentence), stdin);
    printf("你输入的句子：%s", sentence);
    
    return 0;
}

字符串处理函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>
#include <string.h>

int main() {
    char str1[50] = "Hello";
    char str2[50] = "World";
    char str3[100];
    
    // 字符串长度
    printf("str1的长度：%zu\n", strlen(str1));
    
    // 字符串复制
    strcpy(str3, str1);
    printf("复制后str3：%s\n", str3);
    
    // 字符串连接
    strcat(str1, " ");
    strcat(str1, str2);
    printf("连接后str1：%s\n", str1);
    
    // 字符串比较
    char name1[] = "Alice";
    char name2[] = "Bob";
    char name3[] = "Alice";
    
    printf("\n字符串比较：\n");
    printf("\"%s\" vs \"%s\": %d\n", name1, name2, strcmp(name1, name2));
    printf("\"%s\" vs \"%s\": %d\n", name1, name3, strcmp(name1, name3));
    printf("\"%s\" vs \"%s\": %d\n", name2, name1, strcmp(name2, name1));
    
    // 字符串查找
    char text[] = "Hello, World!";
    char *pos = strstr(text, "World");
    if (pos != NULL) {
        printf("\n在\"%s\"中找到\"World\"，位置：%ld\n", text, pos - text);
    }
    
    return 0;
}

多维数组

二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>

int main() {
    // 二维数组的声明和初始化
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    // 部分初始化
    int grid[3][3] = {{1, 2}, {4, 5, 6}, {7}};
    
    // 输出二维数组
    printf("3×4矩阵：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    printf("\n3×3网格：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%3d ", grid[i][j]);
        }
        printf("\n");
    }
    
    // 修改二维数组元素
    matrix[1][2] = 99;
    printf("\n修改matrix[1][2]后：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

二维数组的应用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>

int main() {
    // 学生成绩表（3个学生，4门课程）
    float scores[3][4] = {
        {85.5, 92.0, 78.5, 96.0},  // 学生1
        {88.0, 85.5, 91.0, 87.5},  // 学生2
        {92.5, 89.0, 94.5, 90.0}   // 学生3
    };
    
    char subjects[4][20] = {"数学", "英语", "物理", "化学"};
    
    printf("学生成绩表：\n");
    printf("学生\t");
    for (int j = 0; j < 4; j++) {
        printf("%-8s", subjects[j]);
    }
    printf("平均分\n");
    
    // 计算每个学生的平均分
    for (int i = 0; i < 3; i++) {
        printf("学生%d\t", i + 1);
        float sum = 0;
        for (int j = 0; j < 4; j++) {
            printf("%-8.1f", scores[i][j]);
            sum += scores[i][j];
        }
        printf("%.1f\n", sum / 4);
    }
    
    // 计算每门课程的平均分
    printf("\n课程平均分：\n");
    for (int j = 0; j < 4; j++) {
        float sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += scores[i][j];
        }
        printf("%s：%.1f\n", subjects[j], sum / 3);
    }
    
    return 0;
}

数组作为函数参数

一维数组作为参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include <stdio.h>

// 数组作为参数传递（实际传递的是指针）
void print_array(int arr[], int size) {
    printf("数组元素：");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 计算数组总和
int sum_array(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

// 查找数组中的最大值
int find_max(int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

// 修改数组元素（演示数组参数的引用特性）
void double_array(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;
    }
}

// 数组排序（冒泡排序）
void bubble_sort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int numbers[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("原始数组：\n");
    print_array(numbers, size);
    
    printf("数组总和：%d\n", sum_array(numbers, size));
    printf("最大值：%d\n", find_max(numbers, size));
    
    printf("\n将数组元素翻倍：\n");
    double_array(numbers, size);
    print_array(numbers, size);
    
    printf("\n排序后：\n");
    bubble_sort(numbers, size);
    print_array(numbers, size);
    
    return 0;
}

二维数组作为参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <stdio.h>

// 二维数组作为参数（必须指定列数）
void print_matrix(int matrix[][4], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d ", matrix[i][j]);
        }
        printf("\n");
    }
}

// 计算矩阵所有元素的和
int matrix_sum(int matrix[][4], int rows) {
    int sum = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            sum += matrix[i][j];
        }
    }
    return sum;
}

// 矩阵转置（仅适用于方阵）
void transpose_matrix(int matrix[][4], int size) {
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            int temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

int main() {
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    printf("原始矩阵：\n");
    print_matrix(matrix, 3);
    
    printf("\n矩阵元素总和：%d\n", matrix_sum(matrix, 3));
    
    // 方阵示例
    int square[4][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
        {13, 14, 15, 16}
    };
    
    printf("\n原始方阵：\n");
    print_matrix(square, 4);
    
    transpose_matrix(square, 4);
    printf("\n转置后：\n");
    print_matrix(square, 4);
    
    return 0;
}

数组的高级应用

数组搜索算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <stdio.h>

// 线性搜索
int linear_search(int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i;  // 返回找到的索引
        }
    }
    return -1;  // 未找到
}

// 二分搜索（要求数组已排序）
int binary_search(int arr[], int size, int target) {
    int left = 0, right = size - 1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return -1;
}

int main() {
    int numbers[] = {2, 5, 8, 12, 16, 23, 38, 45, 67, 78};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    int target = 23;
    
    printf("数组：");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // 线性搜索
    int linear_result = linear_search(numbers, size, target);
    if (linear_result != -1) {
        printf("线性搜索：在索引%d找到%d\n", linear_result, target);
    } else {
        printf("线性搜索：未找到%d\n", target);
    }
    
    // 二分搜索
    int binary_result = binary_search(numbers, size, target);
    if (binary_result != -1) {
        printf("二分搜索：在索引%d找到%d\n", binary_result, target);
    } else {
        printf("二分搜索：未找到%d\n", target);
    }
    
    return 0;
}

数组统计和分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
#include <stdio.h>

// 计算数组的各种统计信息
void array_statistics(int arr[], int size) {
    if (size == 0) {
        printf("数组为空\n");
        return;
    }
    
    int sum = 0;
    int max = arr[0];
    int min = arr[0];
    int max_index = 0;
    int min_index = 0;
    
    // 计算基本统计信息
    for (int i = 0; i < size; i++) {
        sum += arr[i];
        
        if (arr[i] > max) {
            max = arr[i];
            max_index = i;
        }
        
        if (arr[i] < min) {
            min = arr[i];
            min_index = i;
        }
    }
    
    float average = (float)sum / size;
    
    // 计算方差
    float variance = 0;
    for (int i = 0; i < size; i++) {
        float diff = arr[i] - average;
        variance += diff * diff;
    }
    variance /= size;
    
    printf("=== 数组统计信息 ===\n");
    printf("元素个数：%d\n", size);
    printf("总和：%d\n", sum);
    printf("平均值：%.2f\n", average);
    printf("最大值：%d (索引%d)\n", max, max_index);
    printf("最小值：%d (索引%d)\n", min, min_index);
    printf("方差：%.2f\n", variance);
}

// 统计数组中各数字的出现次数
void count_frequency(int arr[], int size) {
    printf("\n=== 频率统计 ===\n");
    
    // 简单的频率统计（假设数字范围不大）
    int counted[1000] = {0};  // 假设数字在0-999范围内
    
    for (int i = 0; i < size; i++) {
        if (arr[i] >= 0 && arr[i] < 1000) {
            counted[arr[i]] = 1;  // 标记已统计
        }
    }
    
    for (int i = 0; i < size; i++) {
        if (arr[i] >= 0 && arr[i] < 1000 && counted[arr[i]] == 1) {
            int count = 0;
            for (int j = 0; j < size; j++) {
                if (arr[j] == arr[i]) {
                    count++;
                }
            }
            printf("数字%d出现%d次\n", arr[i], count);
            counted[arr[i]] = 0;  // 避免重复统计
        }
    }
}

int main() {
    int data[] = {85, 92, 78, 85, 96, 88, 92, 85, 90, 78};
    int size = sizeof(data) / sizeof(data[0]);
    
    printf("数据数组：");
    for (int i = 0; i < size; i++) {
        printf("%d ", data[i]);
    }
    printf("\n\n");
    
    array_statistics(data, size);
    count_frequency(data, size);
    
    return 0;
}

实际应用示例

示例1：学生成绩管理系统

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include <stdio.h>
#include <string.h>

#define MAX_STUDENTS 50
#define MAX_NAME_LENGTH 30

// 学生信息结构
typedef struct {
    char name[MAX_NAME_LENGTH];
    int id;
    float scores[4];  // 4门课程成绩
    float average;
} Student;

// 计算学生平均分
void calculate_average(Student *student) {
    float sum = 0;
    for (int i = 0; i < 4; i++) {
        sum += student->scores[i];
    }
    student->average = sum / 4;
}

// 输入学生信息
void input_student(Student *student) {
    printf("请输入学生姓名：");
    scanf("%s", student->name);
    printf("请输入学号：");
    scanf("%d", &student->id);
    
    char subjects[4][10] = {"数学", "英语", "物理", "化学"};
    for (int i = 0; i < 4; i++) {
        printf("请输入%s成绩：", subjects[i]);
        scanf("%f", &student->scores[i]);
    }
    
    calculate_average(student);
}

// 显示学生信息
void display_student(const Student *student) {
    printf("%-10s %8d ", student->name, student->id);
    for (int i = 0; i < 4; i++) {
        printf("%6.1f ", student->scores[i]);
    }
    printf("%6.1f\n", student->average);
}

// 显示所有学生信息
void display_all_students(const Student students[], int count) {
    printf("\n=== 学生成绩表 ===\n");
    printf("%-10s %8s %6s %6s %6s %6s %6s\n", 
           "姓名", "学号", "数学", "英语", "物理", "化学", "平均分");
    printf("--------------------------------------------------------\n");
    
    for (int i = 0; i < count; i++) {
        display_student(&students[i]);
    }
}

// 查找最高分学生
int find_top_student(const Student students[], int count) {
    int top_index = 0;
    for (int i = 1; i < count; i++) {
        if (students[i].average > students[top_index].average) {
            top_index = i;
        }
    }
    return top_index;
}

// 计算班级各科平均分
void calculate_subject_averages(const Student students[], int count) {
    char subjects[4][10] = {"数学", "英语", "物理", "化学"};
    
    printf("\n=== 各科平均分 ===\n");
    for (int subject = 0; subject < 4; subject++) {
        float sum = 0;
        for (int i = 0; i < count; i++) {
            sum += students[i].scores[subject];
        }
        printf("%s：%.1f\n", subjects[subject], sum / count);
    }
}

int main() {
    Student students[MAX_STUDENTS];
    int student_count = 0;
    int choice;
    
    printf("学生成绩管理系统\n");
    
    do {
        printf("\n=== 主菜单 ===\n");
        printf("1. 添加学生\n");
        printf("2. 显示所有学生\n");
        printf("3. 显示最高分学生\n");
        printf("4. 显示各科平均分\n");
        printf("0. 退出\n");
        printf("请选择：");
        scanf("%d", &choice);
        
        switch (choice) {
            case 1:
                if (student_count < MAX_STUDENTS) {
                    input_student(&students[student_count]);
                    student_count++;
                    printf("学生信息添加成功！\n");
                } else {
                    printf("学生数量已达上限！\n");
                }
                break;
            case 2:
                if (student_count > 0) {
                    display_all_students(students, student_count);
                } else {
                    printf("暂无学生记录\n");
                }
                break;
            case 3:
                if (student_count > 0) {
                    int top = find_top_student(students, student_count);
                    printf("\n最高分学生：\n");
                    printf("%-10s %8s %6s %6s %6s %6s %6s\n", 
                           "姓名", "学号", "数学", "英语", "物理", "化学", "平均分");
                    display_student(&students[top]);
                } else {
                    printf("暂无学生记录\n");
                }
                break;
            case 4:
                if (student_count > 0) {
                    calculate_subject_averages(students, student_count);
                } else {
                    printf("暂无学生记录\n");
                }
                break;
            case 0:
                printf("谢谢使用！\n");
                break;
            default:
                printf("无效选择！\n");
                break;
        }
    } while (choice != 0);
    
    return 0;
}

示例2：简单的图像处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <stdio.h>

#define WIDTH 8
#define HEIGHT 6

// 显示图像（用字符表示像素）
void display_image(int image[HEIGHT][WIDTH]) {
    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH; j++) {
            if (image[i][j] == 0) {
                printf(". ");  // 0表示背景
            } else {
                printf("* ");  // 1表示前景
            }
        }
        printf("\n");
    }
}

// 图像反转
void invert_image(int image[HEIGHT][WIDTH]) {
    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH; j++) {
            image[i][j] = 1 - image[i][j];
        }
    }
}

// 水平翻转
void flip_horizontal(int image[HEIGHT][WIDTH]) {
    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH / 2; j++) {
            int temp = image[i][j];
            image[i][j] = image[i][WIDTH - 1 - j];
            image[i][WIDTH - 1 - j] = temp;
        }
    }
}

// 垂直翻转
void flip_vertical(int image[HEIGHT][WIDTH]) {
    for (int i = 0; i < HEIGHT / 2; i++) {
        for (int j = 0; j < WIDTH; j++) {
            int temp = image[i][j];
            image[i][j] = image[HEIGHT - 1 - i][j];
            image[HEIGHT - 1 - i][j] = temp;
        }
    }
}

// 计算前景像素数量
int count_foreground_pixels(int image[HEIGHT][WIDTH]) {
    int count = 0;
    for (int i = 0; i < HEIGHT; i++) {
        for (int j = 0; j < WIDTH; j++) {
            if (image[i][j] == 1) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    // 初始化一个简单的图像
    int image[HEIGHT][WIDTH] = {
        {0, 0, 0, 0, 0, 0, 0, 0},
        {0, 1, 1, 1, 1, 1, 0, 0},
        {0, 1, 0, 0, 0, 1, 0, 0},
        {0, 1, 0, 1, 0, 1, 0, 0},
        {0, 1, 0, 0, 0, 1, 0, 0},
        {0, 1, 1, 1, 1, 1, 0, 0}
    };
    
    int choice;
    
    do {
        printf("\n=== 图像处理菜单 ===\n");
        printf("1. 显示图像\n");
        printf("2. 反转图像\n");
        printf("3. 水平翻转\n");
        printf("4. 垂直翻转\n");
        printf("5. 统计前景像素\n");
        printf("0. 退出\n");
        printf("请选择：");
        scanf("%d", &choice);
        
        switch (choice) {
            case 1:
                printf("\n当前图像：\n");
                display_image(image);
                break;
            case 2:
                invert_image(image);
                printf("\n图像已反转\n");
                display_image(image);
                break;
            case 3:
                flip_horizontal(image);
                printf("\n图像已水平翻转\n");
                display_image(image);
                break;
            case 4:
                flip_vertical(image);
                printf("\n图像已垂直翻转\n");
                display_image(image);
                break;
            case 5:
                printf("\n前景像素数量：%d\n", count_foreground_pixels(image));
                break;
            case 0:
                printf("退出程序\n");
                break;
            default:
                printf("无效选择！\n");
                break;
        }
    } while (choice != 0);
    
    return 0;
}

常见错误和注意事项

1. 数组越界

1
2
3
4
5
6
7
8
9
// 错误：数组越界访问
int arr[5] = {1, 2, 3, 4, 5};
printf("%d\n", arr[5]);  // 错误：索引5超出范围

// 正确：检查数组边界
int size = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < size; i++) {  // 使用 < 而不是 <=
    printf("%d ", arr[i]);
}

2. 数组初始化错误

1
2
3
4
5
6
// 错误：数组大小不匹配
int arr[3] = {1, 2, 3, 4, 5};  // 错误：提供了5个值但数组只有3个元素

// 正确：
int arr1[5] = {1, 2, 3, 4, 5};  // 明确指定大小
int arr2[] = {1, 2, 3, 4, 5};   // 让编译器推断大小

3. 字符串处理错误

1
2
3
4
5
6
// 错误：忘记为字符串结束符预留空间
char str[5] = "Hello";  // 错误："Hello"需要6个字符（包括'\0'）

// 正确：
char str[6] = "Hello";  // 为结束符预留空间
char str2[] = "Hello";  // 让编译器自动计算大小

4. 函数参数传递误解

1
2
3
4
5
6
7
8
9
10
11
12
// 常见误解：认为可以获取数组参数的大小
void wrong_function(int arr[]) {
    int size = sizeof(arr) / sizeof(arr[0]);  // 错误：这里arr是指针
    // sizeof(arr)返回指针大小，不是数组大小
}

// 正确：显式传递数组大小
void correct_function(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}

总结

数组是C语言中最重要的数据结构之一，通过本文的学习，你应该掌握：

  1. 数组基础：声明、初始化和访问
  2. 一维数组：基本操作和应用
  3. 字符数组：字符串处理
  4. 多维数组：二维数组的使用
  5. 数组与函数：参数传递和处理
  6. 高级应用：搜索、排序和统计
  7. 实际项目：完整的应用示例

在实际编程中，要注意：

  • 避免数组越界访问
  • 正确处理数组大小
  • 合理使用数组作为函数参数
  • 注意字符串的特殊性
  • 选择合适的数组维度

掌握数组的使用是学习更高级数据结构（如链表、栈、队列）的基础，也是编写实用程序的重要技能。通过大量的练习和实际应用，你将能够熟练运用数组解决各种编程问题。

版权所有，如有侵权请联系我