C语言入门（三）

1. 什么是数组

int numbers[5] = {1, 2, 3, 4, 5};

这个声明创建了一个名为numbers的数组，它包含了5个整数元素，它是一个一维数组。数组的索引从0开始，因此numbers[0]表示第一个元素，numbers[1]表示第二个元素，以此类推。需注意 数组中的所有元素必须是相同的数据类型，例如整数、浮点数、字符等。

数组可以用在以下方面：

1.存储和处理大量数据：使用数组来存储大量相同类型的数据，比如学生成绩、员工工资、图像像素值等。通过使用数组，方便对这些数据进行访问、处理和计算。

2.循环和迭代：数组通常与循环结构一起使用，可以在程序中重复执行相同的操作。通过循环遍历数组，对数组中的每个元素执行相同的操作，比如求和、计数、查找最大值等。

3.字符串处理：在C语言中，字符串是以字符数组的形式表示的。可以使用字符数组来存储和处理字符串，比如连接、复制、比较、分割等操作。

4.数据结构和算法：数组是许多常见数据结构和算法的基础，比如栈、队列、堆、哈希表等。通过数组，可以实现这些数据结构，进行插入、删除、搜索等操作。

5.多维数据：除了一维数组，C语言支持多维数组，比如二维数组、三维数组等。多维数组在处理矩阵、表格、图形等问题时非常有用。

5.缓冲区和缓存：在系统编程和网络编程中，数组经常被用作缓冲区（buffer）或缓存（cache），用于临时存储数据或传输数据。

6.图形和图像处理：数组可以用于表示和处理图形和图像数据。例如，使用二维数组来表示图像的像素值，通过修改数组中的元素来实现图像处理操作，比如旋转、缩放、滤波等。

7.数据传递：在函数调用中，将数组作为参数传递给函数。这样，函数可以直接访问和修改数组中的元素，便于进行数据处理和传递等。

2. 如何使用数组

首先，声明数组变量。声明数组时需要指定数组的类型和名称，并指定数组的大小（元素的个数）。

数组一般形式：类型名 数组名 [常量表达式];

数组名的命名规则和变量名相同，遵循标识符命名规则，且数组的大小不允许动态定义。在定义数组时，需要指定数组中元素个数，常量表达式用来表示元素个数，即数组长度。常量表达式中可以包括常量和符号常量,int a[a+5];合法，int a[n];是不合法。

int numbers[5]; // 声明一个包含5个整数的数组
float grades[10]; // 声明一个包含10个浮点数的数组

初始化数组，即在定义数组的同时给各数组元素赋值。可以选择在声明数组时进行初始化，或者在后续的代码中给数组的每个元素赋值。

int numbers[5] = {1, 2, 3, 4, 5}; // 声明并初始化数组
float grades[10]; // 声明数组
grades[0] = 95.5; // 给数组的第一个元素赋值
grades[1] = 87.3; // 给数组的第二个元素赋值
// ...

数组的初始化有多种方式，如：

直接在定义时，给数组全部元素赋予初值；
int a[10] ={0,1,2,3,4,5,6,7,8,9};

只给部分元素赋值，其余自动赋0；
int a[10] = {0,1,2,3,4};

在给全部元素赋值的时候，可以不用指定长度，因为元素个数已经确定。
int a[] = {1,2,3,4,5};

访问读取数组元素，使用下标操作符[]来访问数组中的元素。数组的下标从0开始，依次递增。例如，访问数组numbers的第一个元素：

int arr = numbers[0]; // 访问数组的第一个元素
float y = grades[2]; // 读取数组的第三个元素

修改数组元素使用下标操作符[]来修改数组中的元素。例如，修改数组numbers的第二个元素为10：

numbers[1] = 10;

使用循环遍历数组

int i;
for (i = 0; i < 5; i++) {
    printf("%d ", numbers[i]); // 输出数组中的每个元素
}

获取数组长度，使用sizeof运算符来获取数组在内存中所占的总字节数，然后除以每个元素的字节数，即可得到数组的长度。

int length = sizeof(numbers) / sizeof(numbers[0]); // 获取数组的长度

以上为一维数组基本使用方法。

示例2.1 对10个数组元素依次赋值0~9，逆序输出。

#include <stdio.h>
int main()
{
	int i, a[10];
	for (i = 0; i <= 9; i++)
		a[i] = i;
	for (i = 9; i >= 0; i--)
		printf("%d", a[i]);
	printf("\n");
	return 0;
}

3. 二维数组

上面的内容均为一维数组，这里会多解释二维数组。

二者在形式上区分:

一维数组，如int numbers[10]
二维数组，如int numbers[3][4]

二维数组
是一个由多个一维数组组成的表格状数据结构，可以理解为行和列的交叉点构成了二维数组。

3.1 基本使用方法

1. 声明二维数组： 在声明二维数组时，需要指定数组的类型、行数和列数。如，声明一个3行4列的整型二维数组：

int arr[3][4];

2. 初始化二维数组：
同一维数组，二维数组可以在声明时进行初始化，也可以在后续的代码中为数组元素赋值。如，声明并初始化一个包含2行3列的整数二维数组：

int arr[2][3] = { {1, 2, 3}, {4, 5, 6} };

如果只给部分元素赋初值，其他元素将自动被初始化为零。

int arr[2][3] = { {1, 2}, {4} }; // 第一行为1、2、0，第二行为4、0、0

3. 访问二维数组元素：
使用两个下标操作符[][]来访问二维数组中的元素。第一个下标表示行号，第二个下标表示列号。如，访问二维数组arr的第一行第二列的元素：

int element = arr[0][1];

4. 修改二维数组元素：
使用两个下标操作符[][]来修改二维数组中的元素。如，将二维数组arr的第二行第三列的元素修改为10：

arr[1][2] = 10;

5. 二维数组遍历：
可以使用嵌套的循环结构（如双重for循环）来遍历二维数组中的所有元素。如，使用双重for循环打印二维数组arr的所有元素：

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 4; j++) {
        printf("%d ", arr[i][j]);
    }
    printf("\n"); // 换行
}

示例1，这是一个冒泡排序，输入十个数字按从小到大排序

#include <stdio.h>

int main() {
    int numbers[10];
    int i, j, temp;

    // 输入十个数字
    printf("请输入10个数字：\n");
    for (i = 0; i < 10; i++) 
        scanf("%d", &numbers[i]);
        
    // 冒泡排序算法
    for (i = 0; i < 9; i++) {
        for (j = 0; j < 9 - i; j++) {
            if (numbers[j] > numbers[j + 1]) {
                // 交换位置
                temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // 输出排序后的结果
    printf("从小到大排序后的结果：\n");
    for (i = 0; i < 10; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    return 0;
}

4. 字符数组

C语言中没有字符串类型，也没有字符串变量，字符串是存放在字符型数组中的。
字符数组是一种特殊的一维数组，用于存储字符串。在C语言中，字符串实际上是以空字符（‘\0’）结尾的字符数组。而空字符告诉程序字符串在哪里结束，因此通过检查是否遇到空字符来确定字符串的长度。

如果有一个字符数组char str[6] = {'h', 'e', 'l', 'l', 'o', '\0'};，它实际上表示了一个包含5个字符的字符串"hello"。而这5个字符被存储在字符数组str中，最后以空字符结尾。

这里写一个使用示例来说明字符数组然后使用的，后面会展开来说明。

#include <stdio.h>

int main() {
    char str1[] = "Hello, World!"; // 声明并初始化字符数组

    printf("原始字符串: %s\n", str1); // 打印原始字符串

    // 修改字符数组中的内容
    str1[7] = ',';
    str1[8] = ' ';
    str1[9] = 'C';
    str1[10] = 'h';
    str1[11] = 'i';
    str1[12] = 'n';
    str1[13] = 'a';
    str1[14] = '!';
    str1[15] = '\0'; // 添加新的 null 结尾

    printf("修改后的字符串: %s\n", str1); // 打印修改后的字符串

    return 0;
}
//原始字符串: Hello, World!
//修改后的字符串: Hello, China!

4.1 使用方法

1. 声明字符数组：
在字符数组中的一个元素内存放一个字符。

char c[6];
char str[10];

2. 初始化字符数组：

最方便的可以直接将一个字符串字面量赋值给字符数组。

char c[]="I am happy";
char c[6] = "Elysic";
char str[] = "Hello, World!";

这种方法会自动分配足够的空间来存储字符串，并且以 null 字符 (‘\0’) 结尾。

最基本的方式把字符依次赋给数组中各元素。

char c[]={'I','','a','m','','h','a','p','p','y','\0'};

char str[15];
str[0] = 'H';
str[1] = 'e';
str[2] = 'l';
str[3] = 'l';
str[4] = 'o';
str[5] = ',';
str[6] = ' ';
str[7] = 'W';
str[8] = 'o';
str[9] = 'r';
str[10] = 'l';
str[11] = 'd';
str[12] = '!';
str[13] = '\0';

上面这两种比较麻烦。

可以使用 strcpy 函数将一个字符串复制到字符数组中。

#include <string.h>
// ...
char str[15];
strcpy(str, "Hello, World!");

这个需要引入 string.h 头文件，并使用 strcpy 函数将源字符串复制到目标字符数组中。需要确保目标字符数组有足够的空间来容纳复制的字符串。

注意：字符数组并不要求它的最后一个字符为'\0',加上它也是为了便于引用字符数组中的字符串。

如果只给部分元素赋初值，其他元素将自动被初始化为空字符：

char str[10] = "hello"; // 后面5个元素为'\0'

示例4.1 ，用字符*输出一个菱形

#include <stdio.h>
int main()
{
	char diamond[][5] = { {' ',' ','*'},{' ','*',' ','*'},
	{'*',' ',' ',' ','*'},{' ','*',' ','*'},{' ',' ','*'} };
	int i, j;
	for (i = 0; i < 5;i++)
	{
		for (j = 0; j < 5; j++)
			printf("%c", diamond[i][j]);
		printf("\n");
	}
	return 0;
}

4.2字符数组的输入输出

字符数组输入输出有两种方法

• 逐个字符的输入输出。如

#include <stdio.h>
int main()
{
	char c[] = "c language";
	int i;
	for (i = 0; i < 10; i++)
		printf("%c",c[i]);
	return 0;
}

• 将整个字符一次输入或者输出。如

char c[]="China";
printf("%s\n",c);

在内存中数组c的存储情况为

输出时，遇结束符'\0'就停止输出。输出结果为China

注：输出的字符中不包括结束符'\0'。
用“%s”格式符输出字符串时，printf函数中的输出项是字符数组名，而不是数组元素名。
如果一个字符数组中包含一个以上'\0'，则遇到第一个'\0'时输出就结束。

4.3常用字符串处理函数

1. 输出字符串函数
puts(str)
作用：将一个字符串（以'\0'结束的字符序列）输出到终端。

char str[]="Thank\nYou";
puts(str);
//输出：Thank
//      You

用puts函数输出的字符串中可以包含转义符，使用'\n',输出完字符串后换行。
2. 输入字符串函数
gets(str)
作用：通过键盘输入一个字符串到字符数组，并得到一个函数值，该函数值是字符数组的起始地址

3. 字符串连接函数
strcat(str1,str2)
作用：把两个字符数组中的字符串连接起来，把字符串2接到字符串1的后面，结果放在字符数组1中，函数调用后得到字符数组1的地址。

char str1[20]="Genshin";
char str1[]="Impact";
//输出：Genshin Impact

注：字符数组1必须足够大，便于容纳新的字符串
4. 字符串复制函数
strcpy(str1,str2)
作用：将字符串2复制到字符数组1中去。

char str1[10],str2[]="China";
strcpy(str1,str2);
strcpy(str1,"China");

5. 字符串比较函数
strcmp(str1,str2);
作用：比较字符串1和字符串2，从左到右逐个字符相比，直到出现不同的字符或遇到'\0'为止。

如果全部字符相同，则认为两个字符串相等；
若出现不相同的字符，则以第1对不相同的字符的比较结果为准。

注意，strcmp 函数比较字符串时是按照字符的 ASCII 码值进行比较的。如果要比较的字符串中包含中文等非 ASCII 字符，那么使用 strcmp 函数可能会得到错误的结果。

比较的结果由函数值带回。
str1和str2相同，函数值为0；
str1>str2，函数值为一个正整数；
如，computer>compare
str1<str2，函数值为一个负整数。
如，that<these

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello, World!";
    char str2[] = "hello, world!";

    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("字符串相同\n");
    } else if (result < 0) {
        printf("str1 小于 str2\n");
    } else {
        printf("str1 大于 str2\n");
    }

    return 0;
}
//str1 小于 str2

6. 测试字符串长度的函数
strlen(str)

#include <stdio.h>
#include <string.h>

int main() {
    char myString[] = "Elysic";
    int length = strlen(myString);

    printf("字符串长度为：%d\n", length);

    return 0;
}
//输出结果：字符串长度为：6
//如果在字符串中间加空格会变成7

7. 转换为小写的函数
strlwr(str)
用于将字符串中的所有字符转换为小写字母。

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Hello, World!";
    
    printf("原始字符串: %s\n", str);

    _strlwr(str);

    printf("转换后字符串: %s\n", str);

    return 0;
}
//原始字符串: Hello, World!
//转换后字符串: hello, world!

8. 转换为大写的函数
strupr(str)

 char str[] = "Hello, World!";

    printf("原始字符串: %s\n", str);

    _strupr(str);

    printf("转换后字符串: %s\n", str);
//原始字符串: Hello, World!
//转换后字符串: HELLO, WORLD!

5. 数组应用

1.检查数组中是否存在重复的元素。

#include <stdio.h>

int check_duplicates(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                return 1; // 存在重复元素
            }
        }
    }
    return 0; // 不存在重复元素
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 3};
    int n = sizeof(arr) / sizeof(int);

    int has_duplicates = check_duplicates(arr, n);

    if (has_duplicates) {
        printf("Array contains duplicates.\n");
    } else {
        printf("Array does not contain duplicates.\n");
    }

    return 0;
}

2.合并两个已排序的数组。

#include <stdio.h>

void merge_arrays(int arr1[], int n1, int arr2[], int n2, int merged[]) {
    int i = 0, j = 0, k = 0;

    while (i < n1 && j < n2) {
        if (arr1[i] <= arr2[j]) {
            merged[k++] = arr1[i++];
        } else {
            merged[k++] = arr2[j++];
        }
    }

    while (i < n1) {
        merged[k++] = arr1[i++];
    }

    while (j < n2) {
        merged[k++] = arr2[j++];
    }
}

int main() {
    int arr1[] = {1, 3, 5, 7};
    int n1 = sizeof(arr1) / sizeof(int);

    int arr2[] = {2, 4, 6, 8};
    int n2 = sizeof(arr2) / sizeof(int);

    int merged[n1 + n2];

    merge_arrays(arr1, n1, arr2, n2, merged);

    printf("Merged array: ");
    for (int i = 0; i < n1 + n2; i++) {
        printf("%d ", merged[i]);
    }
    printf("\n");

    return 0;
}

3.找出数组中的重复元素。

#include <stdio.h>

void find_duplicates(int arr[], int n) {
    printf("Duplicate elements in the array: ");

    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                printf("%d ", arr[i]);
            }
        }
    }

    printf("\n");
}

int main() {
    int arr[] = {1, 2, 3, 4, 1, 2, 5};
    int n = sizeof(arr) / sizeof(int);

    find_duplicates(arr, n);

    return 0;
}