七:C语言-数组
- 数组是一组相同类型元素的集合
- 数组中存放的是1个或者多个数据,但是数组元素个数不能为0
- 数组中存放的多个数据,类型是相同的
- 数组分为一维数组和多维数组,多维数组一般比较多见的是二维数组
- 存放在数组中的值被称为数组的元素,数组在创建的时候可以指定数组的大小和数组的元素类型
一:一维数组
1.一维数组的创建:
语法格式:
type arr_name[常量值];
type
:指定的是数组中存放数据的类型,可以是char
;short
;int
;float
等,也可以是自定义类型arr_name
:指的是数组的名字[]
:包裹的是常量值,用来指定数组的大小的;在C99
标准之前定义数组的大小只能是由常量指定,不能使用变量。
示例:创建一个数组
int math[10]; //创建一个长度为10,int类型的数组元素
char people[3]; //创建一个长度为3,char类型的数组元素
double English[14]; //创建一个长度为14,double类型的数组元素
2.一维数组的初始化
数组在创建的时候,我们有时会根据一些实际的需求给定一些初始值,这就叫初始化;数组的初始化一般是使用大括号将数据包裹在其中。
示例:数组初始化
//完全初始化
int arr1[5] = {1,2,3,4,5}; //这里指的是数组的元素类型为int
//不完全初始化
int arr2[6] = {1}; //第一个元素的初始化为1,剩余的元素默认初始化为0
//错误的初始化 -- 初始化项过多
int arr3[4] = {1,2,3,4,5};
//如果数组初始化了,是可以省略掉数组的大小的;数组的大小,是编译器根据初始化的内容确定的
int arr4[] = {1,2,3}; //此时数组的大小为3
注意: 数组也是有类型的,数组算是一种自定义类型,去掉数组名留下的就是当前数组的类型
3.一维数组的使用
C语言规定数组是有下标的,下标从0开始,假设数组有n个元素,那么最后一个元素的下标就是n-1,下标就相当于是对数组元素的编号
示例:
//定义一个int类型的数组
int arr5[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
图解:
在C语言中为数组的访问提供了一个操作符[]
,这个操作符叫做下标引用操作符
示例:
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
//访问下标为7的元素(也就是8)
printf("%d\n",arr5[7]);
return 0;
}
示例:通过下标打印所有元素(数组的输出)
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
//通过下标打印所有元素
int i = 0;
for(i=0;i<12;i++)
{
printf("%d ",arr5[i]);
}
return 0;
}
示例:给数组输入自己想要的数据(数组的输入)
#include <stdio.h>
int main()
{
//定义一个int类型的数组
int arr5[12] = {1,2,3,4,5,6,7,8,9,10,11,12};
//输入
int i = 0;
for(i=0;i<12;i++)
{
scanf("%d",&arr5[i]);
}
return 0;
}
4.一维数组在内存中的存储
示例:依次打印数组元素的内存地址
#include <stdio.h>
int main()
{
int arr[5] = {1,2,3,4,5};
int i = 0;
for(i=0;i<5;i++)
{
printf("&arr[%d] = %p\n",i,&arr[i]); //打印地址的占位符是%p
}
return 0;
}
从输出结果可以看出,数组随着下标的增长,地址是由低到高变化的,并且每两个相邻的元素之间相差为4(因为1个int
整型是4个字节);所以得出一个结论:数组在内存中是连续存放的。
5.sizeof()
计算元素个数
sizeof()
是C语言中的一个关键字,作用是用来计算类型或者变量所占内存空间的大小的,同时也可以用来计算数组所占内存空间的大小和数组中的元素个数。
示例:使用
sizeof()
求元素个数
#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,10}; //这个数组是10个元素,而每个元素占4个字节
printf("%d\n",sizeof(arr)); //sizeof(数组名)计算的是数组所占内存空间的大小,并不是元素的个数/长度。单位是字节,结果是40
printf("%d\n",sizeof(arr[0])); //求1个元素所占内存空间的大小
printf("%d\n",sizeof(arr) / sizeof(arr[0])); //用整个数组所占内存空间的大小除以1个元素所占内存空间的大小,所得出的结果就是这个数组的元素个数
return 0;
}
示例:使用
sizeof()
打印每个元素
#include <stdio.h>
int main()
{
int arr[10] = {1,2,3};
int r = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i=0;i<r;i++)
{
printf("%d ",arr[i]);
}
return 0;
}
扩展:在计算一个类型所占内存空间的大小的时候,可以用它的类型,也可以用变量名
#include <stdio.h>
int main()
{
int a = 10;
printf("%d\n",sizeof(a));
printf("%d\n",sizeof a); //在求变量名所占内存空间的大小的时候,可以省略掉()
printf("%d\n",sizeof(int));
return 0;
}
注意:
sizeof()
的计算结果是size_t
类型的,size_t
是无符号的整型类型
size_t
类型的打印格式使用%zd
占位符来打印的,但如果%zd
报错的话,就用%d
;主要是看编译器
二:二维数组
数组的元素都是内置类型的,如果把一维数组做为数组的元素,那么这个数组就被称为二维数组;依此类推,如果把二维数组做为数组的元素,那么这个数组就被称为三维数组,三维数组以上的数组统称为多维数组。
1.二维数组的创建
语法格式:
type arr_name[常量值1][常量值2];
- type
:指定的是数组中存放数据的类型,可以是
char;
short;
int;
float`等,也可以是自定义类型 arr_name
:指的是数组的名字[]
:包裹的是常量值,用来指定数组的大小的;在C99
标准之前定义数组的大小只能是由常量指定,不能使用变量。- 常量值1:用来指定数组有几行
- 常量值2:用来指定数组有几列
示例:
int arr[3][5];
//int表示数组的每个元素都是整数类型
//arr是数组名
//3表示数组有3行
//5表示数组每一行有5个元素
2.二维数组的初始化
在创建变量或者数组的时候,给定一些初始值,被称为初始化,二维数组也是使用大括号进行初始化的
示例:二维数组的初始化是一行一行放的,当元素把一行放满后,才会进入下一行
#include <stdio.h>
int main()
{
//不完全初始化
int arr1[3][5] = {1,2};
int arr2[2][6] = {0};
int arr3[4][8] = {1,2,3,4,5,6};
//完全初始化
int ar1[3][5] = {1,1,1,1,1,2,2,2,2,2,3,3,3,3,3};
//按照行来进行初始化
int a1[3][5] = {{1,2},{3,4}{5,6,7}};
//二维数组在初始化时可以省略行但不能省略列
int arr4[][5] = {1,2,3}; //这里有1行
int arr5[][4] = {1,2,3,4,5,6}; //这里有2行
int arr6[][3] = {{1,2},{3,4},{5,6}}; //这里有3行
return 0;
}
3.二维数组的使用
对二维数组的访问也是使用下标来获取元素的,二维数组是有行和列的,只要锁定了行和列就可以唯一锁定数组中的某一个元素。而C语言规定,二维数组行和列的下标都是从0开始的。
示例:
int arr[3][4] = {1,2,3,4,5,6,7,8,4,5,6,7};
图解:
示例:访问二维数组中的元素
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {1,2,3,4,5,6,7,8,4,5,6,7};
//通过行和列的下标引用操作符来定位3这个元素
printf("%d\n",arr[0][2]);
return 0;
}
示例:通过下标打印所有元素(二维数组的输出)
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {1,2,3,4,5,6,7,8,4,5,6,7};
//通过下标打印所有元素(数组的输出)
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
printf("%d ",arr[i][j]);
}
printf("\n");
}
return 0;
}
示例:给数组输入自己想要的数据(二维数组的输入)
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {1,2,3,4,5,6,7,8,4,5,6,7};
//给数组输入自己想要的数据(二维数组的输入)
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
scanf("%d",&arr[i][j]);
}
printf("\n");
}
return 0;
}
4.二维数组在内存中的存储
示例:依次打印二维数组中元素的内存地址
#include <stdio.h>
int main()
{
//定义一个int类型的二维数组
int arr[3][4] = {1,2,3,4,5,6,7,8,4,5,6,7};
//通过下标打印所有元素(数组的输出)
int i = 0;
for(i=0;i<3;i++)
{
int j = 0;
for(j=0;j<4;j++)
{
printf("&arr[%d][%d] = %p\n",i,j,&arr[i][j]);
}
printf("\n");
}
return 0;
}
从输出结果可以看出,二维数组中每一行内部的每个元素都是相邻的,二维数组随着下标的增长,地址是由低到高变化的,并且每两个相邻的元素之间相差为4(因为1个int
整型是4个字节),跨行位置处的两个元素之间也是差4个字节;所以得出一个结论:二维数组在内存中是连续存放的。
5.C99
中的变长数组
在C99
标准之前,C语言在创建数组的时候,对于数组大小的指定只能使用常量;常量表达式,或者在初始化数据的时候去省略数组的大小,这样的语法创建,让我们在创建数组的时候显得不够灵活,有时候数组大了浪费空间,数组小了又不够用。
示例:
//在C99之前创建数组的方式
int arr1[10]; //使用常量来指定数组的大小
int arr2[7+1]; //使用常量表达式来指定数组的大小
int arr3[] = {1,2,3}; //初始化数据的时候省略数组的大小
而在C99
标准中给出一个**变长数组(variable-length array 简称VLA
)**的新特性,允许我们可以使用变量来指定数组的大小。
示例:
//在C99之后创建数组的方式 -- 变长数组(允许数组的大小是变量的)
#include <stdio.h>
int main()
{
int i = 0;
scanf("%d",&i);
int arr[i]; //变长数组是不能初始化的,会发生报错
return 0;
}
在上面的示例中,arr
就是一个变长数组,因为它的长度取决于变量i
的值,编译器没办法事先确定,只有在运行时才能知道i
是多少。
- 变长数组的根本特征就是数组的长度只有在运行时才能够确定,所以变长数组不能被初始化。
- 变长数组的好处是程序员不必在开发时,随意为数组指定一个估计的长度,程序可以在运行时为数组分配一个精确的长度。
- 变长数组的意思是数组的大小是可以通过变量来指定的,在程序运行的时候,根据变量的大小来指定数组的元素个数,而不是说数组的大小是可变的,数组的大小一旦被确定就不能再变化了
注意:
这个程序此时仍然会发生报错,因为VS虽然支持了C99
的语法,但并不是全部支持(变长数组在VS上就是不支持的)(大家可以使用其它的编译器试一下)
6.题目练习
示例1:编写代码,演示多个字符从两端移动,同时向中间汇聚
如:
ABCDEFGHIJK
***********
A*********K
AB*******JK
#include <stdio.h>
#include <string.h>
#include <windows.h> //休眠函数的头文件
int main()
{
char arr1[] = "ABCDEFGHIJK";
char arr2[] = "***********";
int left = 0;
int right = strlen(arr1) - 1;
while(left<=right)
{
arr2[left] = arr1[left];
arr2[right] = arr1[right];
printf("%s\n",arr2);
//添加一个动态的效果,让它运行的时候休眠1秒
Sleep(1000); //休眠函数,单位是毫秒
//在一行上让其向两端移动
system("cls"); //用来执行系统命令的
left++;
right--;
}
//在system()全部清理完成后再打印一次完整的结果
printf("%s\n",arr2);
return 0;
}
示例2:二分查找
二分查找也叫做折半查找,是在一个指定的有序数组中,查找具体的一个数字n,对于这种题目,可以使用遍历和二分查找来做,但遍历数组相比于二分查找,效率比较低
如(1):用遍历完成
int arr[] = {1,2,3,4,5,6,7,8,9,10};
在arr这个数组中查找到7这个数字;如果找到了就打印下标,找不到就打印找不到
#include <stdio.h>
int main() {
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
int target = 0;
scanf("%d", &target);
int found = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == target) {
printf("找到数字%d,下标为%d\n", target, i);
found = 1;
break;
}
}
if (found == 0) {
printf("找不到数字%d\n", target);
}
return 0;
}
如(2):用二分查找完成
int arr[] = {1,2,3,4,5,6,7,8,9,10};
在arr这个数组中查找到7这个数字;如果找到了就打印下标,找不到就打印找不到
#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9,10};
int k = 0;
int s = sizeof(arr)/sizeof(arr[0]);
scanf("%d",&k);
//二分查找
int left = 0;
int right = s - 1;
int find = 0; //假设找不到
while(left<=right)
{
int mid = (left + right) / 2;
if(arr[mid] < k)
{
left = mid + 1;
}
else if(arr[mid] > k)
{
right = mid - 1;
}
else
{
printf("找到了,下标是%d\n",mid);
find = 1;
break;
}
}
if(find == 0)
{
printf("找不到该元素\n");
}
return 0;
}
注意:
当数字过大时超出整型所能表示的最大值(INT_MAX == 2147483647)的时候,内存会溢出,数据会出现错误
扩展:
#include <stdio.h>
int main()
{
int a = 2147483647;
int b = 2147483647;
// int c = (a + b) / 2; //在这种情况下数据会出现错误
int c = a + (b-a) / 2; //这种方法会保证数据正常,不会出现问题
printf("%d\n",c);
return 0;
}
right = mid - 1;
}
else
{
printf("找到了,下标是%d\n",mid);
find = 1;
break;
}
}
if(find == 0)
{
printf("找不到该元素\n");
}
return 0;
}
注意:
当数字过大时超出整型所能表示的最大值(INT_MAX == 2147483647)的时候,内存会溢出,数据会出现错误
扩展:
#include <stdio.h>
int main()
{
int a = 2147483647;
int b = 2147483647;
// int c = (a + b) / 2; //在这种情况下数据会出现错误
int c = a + (b-a) / 2; //这种方法会保证数据正常,不会出现问题
printf("%d\n",c);
return 0;
}