数组的先容

1.数组的概念

数组是一组相同范例元素的集合，从这个描述中我们知道：

• 数组中存放1个或多个数据，但是数组的元素个数不为0。
  
• 数组中存放的多个数据，范例是相同的。
  

数组分为一维数组和多维数组，多维数组一样平常比力多见的是二维数组。
2.一维数组的创建和初始化

2.1数组的创建

一维数组创建的格式如下：
   type arr_name[常量值];
  存放在数组的值被称为数组的元素，数组在创建的时间可以指定数组的巨细和数组的元素范例。

• type 指定的是数组中存放的数据的范例，可以是 char、int、short、float 等等，也可以是自界说的范例。
  
• arr_name 指的是数组名的名字，这个名字根据实际的情况，故意义就行。
  
• [ ] 中的常量值是用来指定数组的巨细，这个数组的巨细是根据实际的需求指定就行。
  

如果我们要存放20个人的数学成绩，就可以创建这样一个数组：
   int math[20];
  同样，也可以创建其他范例和巨细的数组：
   char ch[5];
  float score[32];
  2.2数组的初始化

创建数组的同时我们可以给数组内里的一些数据赋值，这种就被称为初始化。
如何给数组初始化呢？数组的初始化一样平常使用大括号 { }，将初始化的数据放在大括号中 

1. //完全初始化
3. int arr1[5]={1,2,3,4,5};
5. //不完全初始化
7. int arr2[5]={ 0 };
9. //错误的初始化 —— 初始化的项太多
11. int arr3[3]={1,2,3,4,5};

复制代码

2.3数组的范例

数组也是有范例的，数组算是一种自界说范例，去掉数组名剩下的就是数组的范例。
   int arr1[10];
  char arr2[5];
  float arr3[6];
  留意：
arr1数组的范例是：int [10]
arr2数组的范例是：char [5]
arr3数组的范例是：float [6]
而在 [ ] 前面的 int、char、float 是 [ ] 中元素的范例
3.一维数组的使用

一维数组可以存放数据，存放数据的目的是对数据的操作。
3.1数组的下标

C语言规定数组是有下标的，下标是从 0 开始的，如果数组有 n 个元素，那么最后一个元素的下标就是 n-1 ，下标就相当于是数组元素的编号：

在C语言中数组的访问提供了一个操作符 [ ] ,这个操作符叫：下标引用操作符
有了下标访问操作符，就可以轻松的访问到数组的元素了，如果我们访问下标为5的元素，我们就是用 arr[5],想访问下标是 3 的元素，就可以使用 arr[3],代码如下：

1. #include <stdio.h>
3. int main(){
5. int arr[10]={1,2,3,4,5,6,7,8,9,10};
7. printf("%d\n",arr[5]); //6
9. printf("%d\n",arr[3]); //4
12. return 0;
13. }

复制代码

3.2数组元素的打印

当我们想要访问整个数组元素时，只要产生数组元素的下标就可以了，我们用 for 循环产生 0-9 的下标，使用下标访问就可以了：

1. int main()
2. {
3.        
4.         int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//完全初始化
5. //                  0 1 2 3 4 5 6 7 8 9
6.         int i = 0;
7.         for (i = 0; i < 10; i++)
8.         {
10.                 printf("%d ", arr[i]);
11.         }
12.         return 0;
13. }

复制代码

 

3.3数组的输入

当我们想要给数组输入想要的数据又如何操作呢？

1. int main()
2. {
3.         int arr1[10] = { 0 };
4.         int i = 0;
5.         for (i = 0; i < 10; i++)
6.         {
7.                 scanf("%d", &arr1[i]);
8.         }
9.         for (i = 0; i < 10; i++)
10.         {
11.                 printf("%d ", arr1[i]);
12.         }
15.         return 0;
16. }

复制代码

 
4.一维数组在内存中存储

一依次打印数组元素的地址：

1. //数组在内存中的存储
2. int main()
3. {
4.         int arr[10] = { 0 };
5.         int i = 0;
6.         for (i = 0; i < 10; i++)
7.         {
8.                 //&--取地址
9.                 //%p--打印地址
10.                 //编号==地址==C语言中的指针
11.                 printf("&arr[%d]=%p\n",i, &arr[i]);
12.         }
13.         return 0;
14. }

复制代码

 

从上面的输出的结果我们就可以发现随着下标的增长，地址也是由小到大的变化，观察到每两个相邻的元素之间相差4，这是因为元素范例是 int 。可以得出结论：数组在内存中是一连存放的。
5.sizeof盘算数组元素个数

在C语言中是有盘算数组元素个数的关键字：sizeof
sizeof 在C语言中是一个关键字，是可以盘算范例大概是变量的巨细的，同样 sizeof也可以盘算数组的巨细。
代码如下：

1. int main()
2. {
3.         int arr[10] = { 0 };
4.         int i = 0;
5.         printf("%d\n", sizeof(arr));//整个数组的大小，单位是字节
6.         printf("%d\n", sizeof(arr[i]));//数组中的一个元素的大小
7.         int sz = sizeof(arr) / sizeof(arr[i]);//计算数组中的元素个数
8.         printf("%d\n", sz);
9.         return 0;
10. }

复制代码

结果输出的是 ： 40 ，这里盘算的是数组所含内存空间的巨细，单元是 ：字节
从上面的代码我们也可以知道：当知道一个元素的所占字节的巨细，那么数组的元素个数就能算出来了。
6.二维数组的创建

6.1 二维数组的概念

当我们把一维数组作为新的数组元素时，这时间就会构成二维数组。以此类推，当我们把二维数组作为新的数组的元素时，就会构成三维数组，二维数组以上的数组被称为多维数组。

6.2二维数组的创建

二维数组的格式如下：
   type arr_name[常量值1][常量值2]； 
  例如：
  int arr1[3] [5];
  

• 3表现数组有3行
  
• 5表现数组每一行有5个元素<==>有5列 
  
• int 表现数组的每个元素范例是整型范例
  
• arr是数组名，可以根据本身的需求来命名
  

7.二维数组的初始化

同一维数组一样，也是用大括号来初始化。
7.1不完全初始化

   int arr1[3][5]={1,2,3};
  int arr2[3][5]={0};
   

7.2完全初始化

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

7.3按照行初始化

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

7.4初始化时可以省略行，但是不能省略列

   int arr5[ ][5]={1,2,3};
  int arr6[ ][5]={1,2,3,4,5,6,7,8} ;
  int arr7[ ][5]={{1,2},{3,4},{5,6,7,8}} ;
  

8.二维数组的使用

8.1二维数组的输入和输出

用两个 for 分别来控制列和行的输入，列嵌在行内里，代码如下：

1. int main()
2. {
3.         int arr[3][5] = { 0 };
4.         int i = 0;//遍历⾏
5.         //输⼊
6.         for (i = 0; i < 3; i++) //产⽣⾏号
7.         {
8.                 int j = 0;
9.                 for (j = 0; j < 5; j++) //产⽣列号
10.                 {
11.                         scanf("%d", &arr[i][j]); //输⼊数据
12.                 }
13.         }
14.         //输出
15.         for (i = 0; i < 3; i++) //产⽣⾏号
16.         {
17.                 int j = 0;
18.                 for (j = 0; j < 5; j++) //产⽣列号
19.                 {
20.                         printf("%d ", arr[i][j]); //输出数据
21.                 }
22.                 printf("\n");
23.         }
24.         return 0;
25. }

复制代码

9.二维数组的在内存中的存储

同一维数组一样如果想要研究内存中的存储方式，我们也可以打印数组全部元素的地址。代码如下：

1. int main()
2. {
3.         int arr[3][5] = { 0 };
4.         int i = 0;
5.         int j = 0;
6.         for (i = 0; i < 3; i++)
7.         {
8.                 for (j = 0; j < 5; j++)
9.                 {
10.                         printf("&arr[%d][%d]=%p\n", i, j, &arr[i][j]);
11.                 }
13.         }

复制代码

 
从输出的结果我们可以瞥见每两个相邻的地址之间相差4个字节，当然跨行位置处的两个元素同样也是，所以二维数组中的每个元素都是一连存放的

10.数组的训练

训练一：多个字符从两端移动，向中心汇集

1. //练习1 多个字符从两端移动，向中间汇聚
2. #include<string.h>
3. #include<windows.h>
4. #include<stdlib.h>
5. #include<stdio.h>
6. int main() {
7.         char arr1[] = "welcome to bit!!!!!!";
8.         char arr2[] = "####################";
9.         int left = 0;
10.         int right = strlen(arr1) - 1;
11.         while (left<=right)
12.         {
13.        
14.                 arr2[left] = arr1[left];
15.                 arr2[right] = arr1[right];
16.                 printf("%s\n",arr2);
17.                 Sleep(1000);
18.                 system("cls");
19.                 left++;
20.                 right--;
21.         }
22.         printf("%s\n", arr2);
27.         return 0;
28. }

复制代码

训练二：二分查找

留意：
二分查找的唯一一个要求就是：数组是有次序的

1. int main()
2. {
3.         int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
4.         int k = 0;
5.         scanf("%d", &k);
6.         int sz = sizeof(arr)/ sizeof(arr[0]);
7.         int left = 0;
8.         int right = sz - 1;
9.         while (left <= right)
10.         {
11.                 int mid = (right + left) / 2;
12.                 if (arr[mid] == k)
13.                 {
14.                         printf("找到了,下标是%d\n",mid);
15.                         break;
16.                 }
17.                 else if (arr[mid] < k)
18.                 {
19.                         left = mid + 1;
20.                 }
21.                 else {
22.                         right = mid - 1;
23.                 }
25.         }
26.         //跳出循环
27.         if (left > right)
28.         {
29.                 printf("找不到\n");
30.         }
32.         return 0;
33. }

复制代码

1. int main()
2. {
3.         int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
4.         int k = 0;
5.         scanf("%d", &k);
6.         int sz = sizeof(arr) / sizeof(arr[0]);
7.         int left = 0;
8.         int right = sz - 1;
9.         int flag = 0;
10.         while (left <= right)
11.         {
12.                 int mid = (right + left) / 2;
13.                 if (arr[mid] == k)
14.                 {
15.                         printf("找到了,下标是%d\n", mid);
16.                         flag = 1;
17.                         break;
18.                 }
19.                 else if (arr[mid] < k)
20.                 {
21.                         left = mid + 1;
22.                 }
23.                 else {
24.                         right = mid - 1;
25.                 }
27.         }
28.         //跳出循环
29.         if (flag==0)
30.         {
31.                 printf("找不到\n");
32.         }
34.         return 0;
35. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。