C语言——数组
1. 数组的概念
数组是一组相同类型元素的集合
- 数组中存放的是1个或者多个数据，但是数组元素个数不能为0
- 数组中存放的多个数据的类型是相同的
数组分为一维数组和多维数组，多维数组一般比较多见的是二维数组
2. 一维数组的创建和初始化
2.1 一维数组的创建
基本语法：
type arr_name[常量值]：
存放在数组的值被称为数组的元素，数组在创建的时候可以指定数组的大小和数组的类型元素
-
type指的是数组存放的类型，可以是：char、short、int等
-
arr_name指的是数组名的名字，这个名字可以根据实际情况来取
-
[]中的常量值用来指定数组的大小，这个数组的大小也是根据实际情况来规定
2.2 一维数组的初始化
在创建数组的时候，我们会给数组一些初始值，这个就叫初始化
我们在对数组进行初始化时，需要将数据放在大括号内
1. int arr1[5] = {1,2,3,4,5} //完全初始化
2. int arr2[6] = {1} //不完全初始化，这个的意思为，第一个元素初始化 为1，后面的5个元素默认为0
3. int arr3[3] = {1,2,3,4} //错误的初始化，初始化的项太多了
3. 一维数组的使用
3.1 数组下标
C语言中数组是有下标的，且数组的下标是从0开始，如果数组有n个元素，则第一个元素下标为0，最后一个元素下标为n-1
int arr[7] = {1,2,3,4,5,6,7,8,9,10};
下图为数组元素对应的下标
现在，我们举一个例子来加深我们对数组下标的理解
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d", arr[7]);
return 0;
}
输出结果
由此，我们知道，如果想要访问数组中的某个元素，只需要有下标引用符[]
下标引用符[]是C语言为数组访问而提供的一个操作符
例如，当我们需要打印数字8，只需向上图一样，使用arr[7]，如果使用arr[0],则打印的结果为1
3.2 数组元素的打印
如果我们想要访问数组中的每个元素，那我们就需要用到for循环，for循环可以产生0到9的下标，我们通过下标访问就可以打印数组中的每个元素
举例：使用for循环打印1-10
3.3 数组的输入和输出
通过3.2数组的打印，我们已经学会了如何打印每一个元素，那么接下来，我们可以自己输入数据，再将其打印出来
4. 一维数组在内存中的存储
为了能够深入了解数组，我们需要了解数组在内存中的存储
用for循环依次打印数组元素的地址：
从上图中，我们可以看出，当数组下标增长，数组地址也会由小到大变化，并且每两个元素之间的地址相差4(一个整型是4个字节)。所以，我们可以知道：数组在内存中是连续存放的。
5. sizeof计算数组元素个数
在遍历数组的时候，我们经常想知道数组元素的个数，如果需要知道数组元素的个数，我们可以用sizeof来计算
sizeof 在C语言中是一个关键字，它可以计算类型、变量以及数组的大小、
举例：计算数组所占内存空间的总大小
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%d", sizeof(arr));
return 0;
}
这个代码计算的是数组所占内存空间的总大小，单位是字节
我们可以知道，数组中所有元素的类型都是相同的，那么，如果我们计算一个元素的大小，我们只需计算数组第一个元素占内存空间的大小
举例：数组第一个元素的占内存空间的大小
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%zd", sizeof(arr[0]));
return 0;
}
这里的4表示一个元素的大小，一个元素有4个字节
接下来，我们可以计算数组元素的个数
举例：数组元素的个数
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%zd", sizeof(arr) / sizeof(arr[0]));
return 0;
}
输出结果为10，表示数组有10个元素
6. 二维数组的创建
6.1 二维数组的概念
数组的元素都是内置类型的，如果我们把一维数组作为数组的元素时，这个时候就是二维数组，二维数组作为数组元素的数组被称为三维数组，二维数组以上的数组统称为多维数组
6.2 二维数组的创建
二维数组的语法
type arr_name[常量1][常量2]
例如
int arr[2][3];
double date[4][5];
从上述代码中，我们可以知道二维数组的具体信息
-
2表示数组有2行
-
3表示数组的每一行有3个元素
-
int表示数组的每个元素的类型为整型
-
arr是数组名，我们可以根据需要指定名字
7. 二维数组的初始化
在创建二维数组时，我们同样可以对二维数组进行初始化
7.1 不完全初始化
int arr1[2][3] = {1,2};
int arr2[2][4] = {0};
arr[1]数组
7.2 完全初始化
int arr[2][3] = {1,2,3, 4,5,6};
7.3 按照行初始化
int arr[3][4] = {{1,2},{3,4},{1,2}};
7.4 初始化时可以省略行，但不能省略列
int arr[][5] = {1,2,3};
8. 二维数组的使用
8.1 二维数组的下标
二维数组访问也是使用下标的形式的，二维数组有行有列，只要锁定了行和列就能唯一锁定数组中的一个元素
数组的行和列都是从0开始
我们同样通过一个例子加深理解
#include<stdio.h>
int main()
{
int arr[3][4] = {1,2,3,4, 2,3,4,5, 3,4,5,6};
printf("%d\n",arr[2][3]);
return 0;
}
打印结果
从上图中，当我们打印arr[2][3]时，在2行3列的元素被打印出来，也就打印6
8.2 二维数组的输入和输出
我们同样可以使用循环访问下标，从而打印数组中的每个元素
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main()
{
int arr[2][3] = { 0 };
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
scanf("%d", &arr[i][j]);
}
}
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
printf("arr[%d][%d] = %d\n",i,j,arr[i][j]);
}
printf("\n");
}
return 0;
}
9. 二维数组在内存中的存储
想要研究二维数组的存储方式，我们也同样需要打印数组的地址
从上图中，我们也可以知道，每一行内部的每个元素都是相邻的，并且地址之间相差4个字节，因此二维数组的每个元素也是连续存放的
10. C99中的变长数组
在C99标准之前，C语言在创建数组的时候，数组大小的指定只能使用常量、常量表达式。或者如果我们初始化数据的话，可以省略数组大小
如：
1 int arr1[10];
2 int arr2[3+5];
3 int arr3[] = {1,2,3};
这样的语法限制，让我们创建数组不太灵活
因此，C99中给了一个变长数组的特性，允许我们可以使用变量指定数组的大小
1 int n = a + b;
2 int arr[n];
在上面的示例中，数组arr就是变长数组，因为它的长度取决于变量n的值，编译器无法事先确定，只有运行时才能知道n是多少。
变长数组的根本特征，就是数组长度只有在运行时才能确定，所以变长数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定一个估计的长度，程序可以在运行时为数组分配精确的长度。但有一个比较迷惑的点，变长数组的意思是数组的大小可以使用变量来指定，在程序运行的时候，根据变量的大小来指定数组的元素个数，但不是说数组的大小是可变的。数组的大小一旦确定就不能再变化了
但是，在VS2022上，虽然支持大部分C99的语法，没有支持C99中的变长数组，没法测试
11.数组的练习
11.1 冒泡排序
11.1.1 冒泡排序理解
冒泡排序是一种简单直观的排序方法，它通过多次遍历待排序的列表，比较相邻 的元素，并交换位置，使数字大的逐步排到列表的末尾，而较小的元素则移动到列表的前端
11.1.2 冒泡排序工作原理
- 遍历列表：从第一个元素开始，依次比较每两个相邻的元素
- 比较和交换：当前一个元素大于后一个元素时，交换它们的位置；当每一轮遍历结束后，数组的正比较的元素移到合适的位置；
- 重复过程：重复比较和交换的过程，直到每个元素到达合适的位置
- 终止循环：当某一轮的遍历没有发生变化时，终止循环
画图来更好的理解
11.1.3 冒泡排序举例
举例：输入俩个数a、b，a表示第一行的元素个数，b表示第二行的元素个数，输出为一行且长度为a+b的升序序列，即长度为a的升序序列和长度为b的升序序列中的元素重新进行升序序列排列合并。
int main()
{
int a, b, arr[2000], temp;
scanf("%d", &a);
scanf("%d", &b);
for (int i = 1; i <= a + b; i++)
{
scanf("%d", &arr[i]);
}
for (int i = 1; i <= a + b; i++)//外层循环控制轮数
{
for (int j = 1; j <= a + b - i; j++)//内层循环比较相邻元素
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 1; i < a + b + 1; i++) {
printf("%d ", arr[i]);
}
return 0;
}
11.2 二分查找
11.2.1 二分查找理解
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法的效率⽐较低。
假设我们要在1到100内猜一个数字，我们可以猜50，这个就是中间数字，然后就可以知道是猜大了还是猜小了，这个就是二分查找
二分查找是一种高效的搜索算法，用于在有序数组中快速定位目标元素的位置。其核心思想是通过每次将搜索范围缩小一半，从而快速逼近目标值，能够显著的减少比较次数，提高搜索效率。
11.2.2 二分查找工作步骤
初始化指针：设置两个指针，left 和 right，分别指向数组的起始和末尾。
计算中间位置：计算当前搜索范围的中间位置 mid，即 mid = (left + right）/ 2
比较中间元素： 如果中间元素 arr[mid] 等于目标值 target，则查找成功，返回 mid。 如果 arr[mid] 小于 target，说明目标值在右半部分，调整 left = mid + 1。 如果 arr[mid] 大于 target，说明目标值在左半部分，调整 right = mid - 1。
终止条件：当 left 超过 right 时，说明目标值不在数组中，查找失败。
11.2.3 二分查找代码举例
举例：
#include<stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int left = 0;
int right = sizeof(arr) / sizeof(arr[0]);
int key = 6; //要找的元素
int mid = 0; //记录中间元素的下标
int find = 0;
while (left <= right)
{
mid = (left + right) / 2;
if (arr[mid] > key)
{
right = mid - 1;
}
else if (arr[mid] - key)
{
left = mid - 1;
}
else
{
find = 1;
break;
}
}
if (1 == find)
printf("找到了，下标是%d\n", mid);
else
printf("找不到\n");
return 0;
}
在代码中，中间元素的下标，我们使用的是mid = (left + right) / 2，但是如果数字太大的话，left和right可能出现问题，所以我们尽量使用
mid = left + (right - left) / 2
11.3 多个字符从两端向中间汇聚
#include<windows.h>
#include<stdio.h>
int main()
{
char arr1[] = "Hello World";
char arr2[] = "***********";
int left = 0;
int right = strlen(arr1) - 1;
printf("%s\n", arr2);
while (left <= right)
{
Sleep(1000);
arr2[left] = arr1[left];
arr2[right] = arr1[right];
left++;
right--;
printf("%s\n", arr2);
}
return 0;
}
扫一扫
1441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
