c语言-数组

概括


1.什么叫数组?为什么要有数组? 2.数组的基本操作 a.查询 b.插入 c.删除 d.简单排序 3.二维数组 4.字符数组和字符串的区别 5.数组越界的问题(垃圾值)
为什么要有数组?什么叫数组?

那个通过前一阵的学习的学习,相信你了解了c语言中的变量,就是先想好变量的类型,定好名字,然后赋值什么的。

对一个变量的基本操作相信你已经会了,那么现在我要你对一群相同的变量进行同样的操作的时候,这个时候你该怎么办? 可能一:一个一个进行操作,反正不嫌麻烦,一个个赋值什么的。

可能二:既然它们都是相同的数据类型,又进行同样的操作,有没有什么办法,让它们统一操作,这样简单方便,节约时间。

相信聪明的你一定会选可能二,这就是数组存在的原因。

至于什么叫数组,相信你已经猜出来了 数组:就是只能存放一种数据类型,比如int类型的数组、float类型的数组,里面存放的数据称为“元素” 数组的定义: 首先声明数组的类型,然后声明数组元素的个数(也就是需要多少存储空间) 格式: 元素类型 数组名[元素个数]; 比如: int a[3]; 就是告诉编译器,你现在有3个int类型的元素放在a这个数组里面 数组元素有顺序之分,每个元素都有一个唯一的下标(索引),而且都是从0开始(这点必须记住) 数组元素的访问: a[i] 数组元素的初始化:  int a[3] = {10, 9, 6};  int a[3] = {10,9};  int a[] = {11, 7, 6};  int a[4] = {[1]=11,[0] = 7}; 数组的初始化 上面的代码是先定义数组再给数组赋值,我们也可以在定义数组的同时赋值: int a[4] = {20, 345, 700, 22}; { }中的值即为各元素的初值,各值之间用,间隔。

对数组赋初值需要注意以下几点: 1) 可以只给部分元素赋初值。

当{ }中值的个数少于元素个数时,只给前面部分元素赋值。

例如: int a[10]={12, 19, 22 , 993, 344}; 表示只给 a[0]a[4] 5个元素赋值,而后面5个元素自动赋0值。

当赋值的元素少于数组总体元素的时候,剩余的元素自动初始化为 0 对于short、int、long,就是整数0; 对于char,就是字符 ‘\0’; 对于float、double,就是小数0.0。

我们可以通过下面的形式将数组的所有元素初始化为 0: int a[10] = {0}; char c[10] = {0}; float f[10] = {0}; 由于剩余的元素会自动初始化为0,所以只需要给第0个元素赋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
#include<stdio.h>

int main()
{
//数组的定义格式: 类型 变量名[元素个数];
//int ages[5];

//数组的赋值方式:
/*
ages[0] = 12;
ages[1] = 19;
ages[2] = 14;
ages[3] = 26;
ages[4] = 18;
*/

//int ages[5] = {[2] = 14,[3] = 26};
//int ages[5] = {12,19};
int ages[5] = {12,19,14,26,18};

//错误写法:
//int ages[];
//错误写法
//int ages[5]; 只能在定义数组的时候进行初始化
//ages = {12,19,14,26,18};
//错误写法,如果想在定义数组的同时进行初始化,数组元素个数必须是常量或者不写
//int ages[count] = {12,19,14,26,18};

/*数组的遍历,按顺序查看数组的每一个元素*/

//1.for循环遍历
for (int i = 0; i <5; i++)
{
printf("ages[%d] = %d\n",i ,ages[i]);
}



return 0;
}

数组的基本操作

查询

在数组中查询有两种情况:

a.知道数组的一个下标,知道该下标的元素的值
b.知道一个元素,想看看数组里面有没有或者求这个元素在数组的下标 这两种都很好操作
a.知道在数组a中,求下标为key的元素,直接在用啊a[key]得出这个元素的值。
b.利用for循环哈,从下标为0的开始找,直到找到或者已经找完全部元素了

1
2
3
4
5
6
for(int i = 0;i < 5;i++){
if(b==a[i]){
printf("元素b的下标为%d",i);
break;
}
}

插入

c语言中,数组是一组连续的相同类型的数据集合。 所以要在数组中插入元素,需要按照以下步骤: 1、找到插入点; 2、将插入点所在元素,及之后的所有元素,都向后移动一个单位; 3、将插入点赋值为要插入的元素。 以固定位置插入,代码举例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
void insert(int *a, int n, int i, int v)
//将长度为n的数组a, 下标为i的位置插入值为v的元素。 插入后,数组长度为n+1.
{
int j;
for(j = n-1; j>=i; j --)//将i及以后的后移一位。 由于是固定位置插入,所以不需要查找插入位置。
a[j+1] = a[j];
a[i] = v;//插入元素。
}

int main()
{
int a[5] = {1,3,6,7};/五个元素数组,初始化四个值。
int i;

insert(a, 4, 2, 5);//将5插入到a[2]位置。
for(i = 0; i < 5; i ++)
printf("%d ", a[i]);//输出结果,为1 3 5 6 7
return 0;
}

删除

c语言中,数组的删除和插入操作类似。 所以要在数组中删除元素,需要按照以下步骤: 1、找到删除点; 2、将插入点所在元素,及之后的所有元素,都向前移动一个单位; 3、数组的元素个数减一; 以固定位置插入,代码举例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "stdio.h"
int main()
{ int a[10],x;//x是要删除数组元素的下标
int i;
for(i=0;i<10;i++)
scanf("%d",&a[i]); //输入10个数据放在数组中
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("请输入要删除元素的下标值:\n");
scanf("%d",&x); //输入要删除的数组元素的下标
for(i=x;i<10;i++)
a[i]=a[i+1];
for(i=0;i<9;i++) //因为删除了一个元素,所以有9个元素
printf("%d ",a[i]);

}

数组的排序

数组的排序是和很重要的一块算法,有很多方法,比如快排,桶排,冒泡排序等等,在你以后的学习中是必须要掌握的,下面只是简单介绍下冒泡排序和桶排序: 冒泡排序 自己对冒泡排序这个名字觉得蛮有意思的,就像鱼鱼吐泡泡一样,小的数不断往上跑,其实这个算法也蛮简单的,就是两重循环,大的循环是要走的趟数,趟数是n-1,n为要排序的数的个数,小循环里面是每循环一次,就把改数组里最大的或最小的数放到最后面,下一次小循环,就把剩下的数,最大的或最小的放在剩下的数的最后面,这样就完成了从小到大排序或从大到小排。

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
#include <stdio.h>
int main(void)
{
int a[100],i,j,t,n;
scanf("%d",&n); //输入要排序的数的个数
for( i =0;i< n;i++)
{
scanf("%d",&a[i]);
}
//冒泡排序的核心部分
for(i =0;i<n-1;i++)
{
for(j=0;j<n-i;j++)
{
if(a[j]<a[j+1])
{
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
for(i =0 ;i < n;i++)
{
printf("%d",a[i]
);
}
return 0;
}

桶排序–最简单最快的排序 桶排序,从名字上都觉得蛮有意思的,它实现的方法很简单,就是弄一大堆桶,每个桶上按顺序贴上标签,比如我要10个数排序,这10个数的范围是0到100,于是我就创建一个啊a[101]的数组数组,也就是100个桶,下标就是代表该桶的值。然后排序的时候,出现一个数,就让该数值的桶里面放个石头,也就是该数组元素的值+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
#include <stdio.h>
int main(void)
{
int book[1000],i,j,k,t,n;
//输出数字的范围是0到999,也就是999个桶
for(i = 0;i < 1000;i++)
{
book[i] = 0; //清空数组,也就是所有桶里一开始没有石头
}

scanf("%d",&n); //输入你要排序多少个数

for(i = 0;i < n;i++) //循环读入n个数
{
scanf("%d",&t);
book[t]++; //桶里放石头哈
}

for(i=1000;i>=0;i--) //从大到小排序
{
for(j=0;j<book[i];j++)
{
printf("%d ",i); //有几个石头就输出几次
}
`

}

return 0;
}

二维数组

二维数组的定义: 一个数组能表示一个班人的年龄,如果想表示很多班呢? 什么是二维数组?int ages[3][10]; 三个班,每个班10个人,相当于3行10列,相当于装着3个一维数组 二维数组是一个特殊的一维数组:它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成,这两个一维数组都包含了3个int类型的元素 定义形式: 类型 数组名[ 行数] [列数] int a[2][3]; //2行3列的二维数组 二维数组的存放顺序是按行存放的,先存放第一行的元素,再存放第2行的元素。例如int a[2][3]的存放顺序是:a[0][0] → a[0][1] → a[0][2] → a[1][0] → a[1][1] → a[1][2] 二维数组的内存存储分配: (注意:a[0]、a[1]也是数组,是一维数组,而且a[0]、a[1]就是数组名,因此a[0]、a[1]就代表着这个一维数组的地址) 1> 数组a的地址是ffc1,数组a[0]的地址也是ffc1,即a = a[0]; 2> 元素a[0][0]的地址是ffc1,所以数组a[0]的地址和元素a[0][0]的地址相同,即a[0] = &a[0][0]; 3> 最终可以得出结论:a = a[0] = &a[0][0],以此类推,可以得出a[1] = &a[1][0] //如果上面的关于地址的方面看不懂的话,没关系,先简单了解下,学完指针再回头来看 二维数组的初始化: 二维数组的初始化 二维数组的初始化可以按行分段赋值,也可按行连续赋值。 例如对数组a[5][3],按行分段赋值可写为: int a[5][3]={ {80,75,92}, {61,65,71}, {59,63,70}, {85,87,90}, {76,77,85} }; 按行连续赋值可写为: int a[5][3]={80, 75, 92, 61, 65, 71, 59, 63, 70, 85, 87, 90, 76, 77, 85}; 这两种赋初值的结果是完全相同的。 对于二维数组初始化赋值还有以下说明 1) 可以只对部分元素赋初值,未赋初值的元素自动取0值。例如: int a[3][3]={ {1},{2},{3}}; 是对每一行的第一列元素赋值,未赋值的元素取0值。 赋值后各元素的值为: 1 0 0 2 0 0 3 0 0 int a [3][3]={ {0,1},{0,0,2},{3}}; 赋值后的元素值为: 0 1 0 0 0 2 3 0 0 2) 如对全部元素赋初值,则第一维的长度可以不给出。例如: int a[3][3]={1,2,3,4,5,6,7,8,9}; 可以写为: int a[][3]={1,2,3,4,5,6,7,8,9}; 3) 二维数组可以看作是由一维数组嵌套而成的,把一维数组的每个元素看作一个数组,就组成了二维数组。当然,前提是各元素类型必须相同。根据这样的分析,一个二维数组也可以分解为多个一维数组,c语言允许这种分解。 如二维数组a[3][4],可分解为三个一维数组,其数组名分别为:a[0]、a[1]、a[2]。 对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素,例如:一维数组a[0]的元素为a[0][0], a[0][1], a[0][2], a[0][3]。必须强调的是,a[0], a[1], a[2]不能当作下标变量使用,它们是数组名,不是一个单纯的下标变量。

字符串和字符数组的区别

用来存放字符的数组称为字符数组,例如:

1
2
3
4
char a[10];  //一维字符数组
char b[5][10]; //二维字符数组
char c[20]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a','m'}; // 给部分数组元素赋值
char d[]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm' }; //对全体元素赋值时可以省去长度

字符数组实际上是一系列字符的集合,也就是字符串(String)。在c语言中,没有专门的字符串变量,没有string类型,通常就用一个字符数组来存放一个字符串。 c语言规定,可以将字符串直接赋值给字符数组,例如:

1
2
char str[30] = {"abcaaaaaaaaaaaa"};
char str[30] = "abcaaaaaaaaaaaa"; //这种形式更加简洁

数组第0个元素为 ‘a’,第1个元素为 ‘b’,第2个元素为 ‘c’,后面的元素以此类推。也可以不指定数组长度,例如:

1
2
char str[] = {"aaaaaaaaaaaaaa"};
char str[] = "aaaaaaaaaaaaaaaa"; //这种形式更加简洁

在c语言中,字符串总是以’\0’作为串的结束符。上面的两个字符串,编译器已经在末尾自动添加了’\0’。 ‘\0’是ASCII码表中的第0个字符,用NUL表示,称为空字符。该字符既不能显示,也不是控制字符,输出该字符不会有任何效果,它在c语言中仅作为字符串的结束标志。 puts 和 printf 在输出字符串时会逐个扫描字符,直到遇见 ‘\0’ 才结束输出。请看下面的例子:

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main(){
int i;
char str1[30] = "aaaaaaaaaa";
char str2[] = "bbbbbbbbbb";
char str3[30] = "You are a good\0 boy!";
printf("str1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
return 0;
}

运行结果: str1: aaaaaaaaaa str2: bbbbbbbbbb str3: You are a good str1 和 str2 很好理解,编译器会在字符串最后自动添加 ‘\0’,并且数组足够大,所以会输出整个字符串。对于 str3,由于字符串中间存在 ‘\0’,printf() 扫描到这里就认为字符串结束了,所以不会输出后面的内容。 需要注意的是,用字符串给字符数组赋值时由于要添加结束符 ‘\0’,数组的长度要比字符串的长度(字符串长度不包括 ‘\0’)大1。例如: char str[] = “C program”; 该数组在内存中的实际存放情况为: 这里写图片描述 字符串长度为 9,数组长度为 10。

数组越界的问题

c语言数组不会自动扩容,当下标小于零或大于等于数组长度时,就发生了越界(Out Of Bounds),访问到数组以外的内存。如果下标小于零,就会发生下限越界(Off Normal Lower);如果下标大于等于数组长度,就会发生上限越界(Off Normal Upper)。 c语言为了提高效率,并不会对越界行为进行检查,即使越界了,也能够正常编译,只有在运行期间才可能会发生问题。请看下面的代码:

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[3] = {10, 20, 30}, i;
for(i=-2; i<=4; i++){
printf("a[%d]=%d\n", i, a[i]);
}
system("pause");
return 0;
}

运行结果: a[-2]=-858993460 a[-1]=-858993460 a[0]=10 a[1]=20 a[2]=30 a[3]=-858993460 a[4]=-858993460 越界访问的数组元素都是垃圾值,没有实际的含义,因为数组之外的内存我们并不知道是什么,可能是其他变量的值,可能是附加数据,可能是一个地址,这些都是不可控的。 由于c语言的”放任“,我们访问数组时必须非常小心,要确保不会发生越界。 当发生数组越界时,如果我们对该内存有访问权限,程序将正常运行,但会出现不可控的结果(如上例所示);如果没有访问权限,程序将会崩溃。请看下面的例子:

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[3];
printf("%d", a[10000]);
system("pause");
return 0;
}

这样的程序会挂,,,每个程序可访问的内存都是有限的,该程序要访问 4*10000 字节处的内存,显然太远了,超出了程序的访问范围。这个地方的内存可能是其他程序的内存,可能是系统本身占用的内存,可能是没被使用的内存,如果放任这种行为,将带来非常危险的后果,操作系统只能让程序停止运行。

数组溢出

当赋予数组的元素个数超过数组长度时,就会发生溢出(Overflow)。如下所示: int a[3] = {1, 2, 3, 4, 5}; 数组长度为3,初始化时却赋予5个元素,超出了数组容量,所以只能保存前3个元素,后面的元素被丢弃。 一般情况下数组溢出不会有什么问题,顶多是丢弃多余的元素。但对于字符数组,有时会产生不可控的情况,请看下面的代码:

1
2
3
4
5
6
7
8
9
#include <stdio.h>
#include <stdlib.h>
int main()
{
char str[10] ="aaaaaaaaaaaaaaaaaaaaaaa";
puts(str);
system("pause");
return 0;
}

在有的编译器下是过不了编译的,有的会输出”aaaaaaaaaa烫烫烫烫”等莫名其妙的汉字. 字符串的长度大于数组长度,数组只能容纳字符串的前面一部分,也就是 “aaaaaaaaaa”,即使编译器在最后添加了 ‘\0’,它也保存不到数组里面,所以 printf() 扫描数组时不会遇到结束符 ‘\0’,只能继续向后扫描。而后面内存中的数据我们不知道是什么,字符能否识别,何时遇到 ‘\0’,这些都是不确定的。当字符无法识别时,就会出现乱码,显示奇怪的字符。 由此可见,在用字符串给字符数组赋值时,要保证数组长度大于字符串长度,以容纳结束符 ‘\0’。

  • 版权声明: 本博客所有文章,未经许可,任何单位及个人不得做营利性使用!转载请标明出处!如有侵权请联系作者。
  • Copyrights © 2015-2020 翟天野

请我喝杯咖啡吧~