ja5.docx
《ja5.docx》由会员分享，可在线阅读，更多相关《ja5.docx（23页珍藏版）》请在冰点文库上搜索。
ja5
第5章数组
在前几章中，我们所使用的都是基本数据类型，如char，int和float等，为了满足某些复杂情况下的编程需要，C语言还提供了构造类型的数据，构造数据类型是由基本数据类型按一定规则组成的，本章要介绍的数组就是一种构造类型的数据。
数组是一组相同类型的变量的集合，数组中的每个成员称为数组元素，每个数组元素都可以当作单个变量来使用，同一个数组中的所有数组元素的数据类型必须相同，可以是基本数据类型，也可以是构造数据类型，因此，按数组元素的类型不同，数组又可分为整型数组，实型数组、字符型数组、指针型数组、结构型数组等。
通过本章的学习，要求掌握一维数组、二维数组和字符数组的定义、初始化以及数组元素的引用等；掌握有关字符串处理函数的使用方法。
5.1一维数组的定义和引用
一维数组通常是指由只有一个下标的数组元素所组成的数组，它是C语言编程中经常使用的一类数组。
5.1.1一维数组的定义
数组在使用中一定要先定义，后引用。
其一般形式为：
类型说明符数组名[常量表达式]；
其中：
类型说明符是任一种基本数据类型或构造数据类型。
数组名是用户定义的标识符，常量表达式是数组元素个数，也称数组的长度。
例如：
inta[10];/*说明数组a有10个元素*/
floatb[10],c[20];/*说明实型数组b有10个元素，实型数组c有20个元素*/
charstr[20];/*说明字符型数组str有20个元素*/
使用数组类型说明时注意：
①数组名的命名规则和变量名相同，遵循标识符规则，但不能与其他变量名重名。
例如：
inta;
floata[10];则是非法的。
②常量表达式可以是符号常量或常量表达式，但不允许为变量。
例如：
intn=5;inta[n];则是非法的。
另外，常量表达式是用一对方括号括起来，不能用圆括号。
③常量表达式表示元素的个数，是从0开始计算的，如a[5]表示数组a有5个元素，这5个元素分别为：
a[0],a[1],a[2],a[3],a[4]。
5.1.2一维数组元素的引用
数组元素是组成数组的基本单元，它也是一种变量，和单个变量的使用方法一样。
一个数组一旦经过类型说明之后，即可使用该数组及其数组元素。
数组元素的一般表示形式：
数组名[下标]
其中，下标只能为整型常量或整型表达式，若为小数，系统自动取整。
例如：
a[5],a[i+j],a[2*2]等都是合法的数组元素。
数组元素通常也称为下标变量，C语言规定只能逐个地引用下标变量，而不能一次引用整个数组。
例如：
要输出有10个元素的数组a，必须使用下面循环语句逐个输出各下标变量：
for（i=0,i<10;i++）printf（"%d",a[i]）;
而不能写成printf（"%d",a）;形式。
【例5.1】数组元素的引用。
#include
main（）
{inti,a[10];
for（i=0;i<10;i++）
a[i]=2*i+1;/*循环把奇数送入数组a的各个元素中*/
for（i=9;i>=0;i--）
printf（"%4d",a[i]）;/*循环把数组元素从大到小输出*/
}
程序运行结果：
191715131197531
对于a[i]=2*i+1;如果输入的数据无规律，则改用scanf（“%d”,&a[i]）;如果输出a[5.2]或a[5.8]）元素的值，则均输出a[5]元素的值，结果为11。
5.1.3一维数组的初始化
数组元素和变量一样，除了用赋值语句对数组元素逐个赋值（如例7.1）外，还可以在类型说明时赋值，称为数组的初始化，对一维数组的初始化通常可以采用三种方式进行。
1.对数组的全部元素赋初值
例如：
inta[10]={0,1,2,3,4,5,6,7,8,9}；
括号{}中的各数据值即为各元素的初始值，各值之间用逗号间隔。
使用时注意：
即使各数组元素的值全部相等，也必须逐个赋值，而不允许给数组整体赋初值。
例如：
整型数组a[5]的5个元素全部为1，初始化时应写成:
inta[5]={1,1,1,1,1};而不能写为：
inta[5]=1;
2．对数组的部分元素赋初值
当括号{}中的值的个数少于元素的个数时，只给前面部分元素赋初值，其余元素自动赋0值。
例如：
inta[10]={0,1,2,3,4};表示只给a[0]～a[4]5个元素赋值，后面的5个元素a[5]～a[9]赋0值。
又如：
intb[5]={0,0,0,0,0};与intb[5]={0};结果相同。
3．对数组的全部元素赋初值时，可以不指定数组长度。
例如：
inta[5]={1,2,3,4,5};可写为：
inta[]={1,2,3,4,5};
系统会根据括号{}中的数值个数，自动定义a数组长度为5。
另外，如果定义数组时不进行初始化，其元素的初值与数组的存储类别有关。
对于存储类别为自动类型的数组其元素的初值为随机的，而对于存储类别为静态的数组或外部数组，其元素的初值为零。
与存储类别有关的知识，将在以后的章节中介绍。
【例5.2】写出下面程序运行结果。
#include
main（）
{inti,a[10]={61,2,13,4,25,6,87,8,39,10}；/*给数组a赋初值*/
for（i=0;i<10;i++）/*循环输出数组元素*/
printf（"%4d”,a[i]）;
}
程序运行结果：
6121342568783910
除上述的初始化赋值和用赋值语句给数组元素赋值外，还有一种给数组元素赋值的方法，即在程序执行过程中，对数组元素作动态赋值。
例如……
for（i=0;i<10;i++）
scanf（"%d,"&a[i]）;
……
执行for语句时，逐个从键盘输入10个数到数组a中。
5.1.4一维数组程序举例
【例5.3】输入20个整数，求出其中负数的个数。
main（）
{inta[20],i,n=0;
for（i=0;i<20;i++）
scanf（“%d”,&a[i]）;
for（i=0;i<20;i++）
if（a[i]<0）n++;
for（i=0;i<20;i++）
{if（i%5==0）printf（"\n"）;/*控制每行输出5项*/
printf（“%8d”,a[i]）;
}
printf（“\n负数共有：
%d\n”,n）;
}
【例5.4】求Fibonacci数列的前20项。
Fibonacci数列的特点是：
前两项为1，1，从第3项开始其值为前两项之和。
其公式为：
1n=1,n=2
fn=
f[n-1]+f[n-2]n>2
#include
main（）
{inti;
longf[20]={1,1};/*部分初始化*/
for（i=2;i<20;i++）
f[i]=f[i-2]+f[i-1]；/*从第3项开始循环，实现后一项为前两项之和*/
for（i=0;i<20;i++）
{if（i%5==0）printf（"\n"）;
printf（“%-12ld”,f[i]）;
}
}
程序运行结果：
11235
813213455
89144233377610
9871597258441816765
【例5.5】输入10个数按从小到大的顺序排列。
这是数组中常用的一个算法——排序问题，排序是将一组随机排放的数按从小到大（升序）或从大到小（降序）重新排列。
排序有冒泡法，选择法等，该例中采用冒泡法实现升序排列。
选择排序的思路是：
设有10个元素a[1]~a[10]，将a[1]与a[2]~a[10]比较，若a[1]比a[2]~a[10]都小，则不进行交换，即无任何操作。
若a[2]~a[10]中有一个以上比a[1]小，则将其中最小的一个（假设为a[k]）与a[1]交换，此时a[1]中存放了10个数中最小的数。
第二轮将a[2]与a[3]~a[10]比较，将剩下9个数中的最小者与a[2]对换，此时a[2]中存放的是10个数中次小的数。
依次类推，共进行9轮比较，a[1]到a[10]就已按由小到大顺序存放。
（本例中定义数组长度为11，对a[0]不用，只用a[1]到a[10]。
）
main（）
{
inta[11];
inti,j,k,t;
printf（"input10numbers:
＼n"）;
for（i=1;i<11;i++）
scanf（"%d"，&a[i]）;
printf（"＼n"）;
for（i=1;i<10;i++）
{k=i;
for（j=i+1;j<=10;j++）
if（a[k]>a[j]）k=j;/*该循环结束时，得到a[k]是a[i]~a[10]中最小者*/
if（k!
=i）/*若a[i+1]~a[10]中有一个以上比a[i]小，则*/
{t=a[i];a[i]=a[k];a[k]=t;}/*将a[i+1]~a[10]中最小者a[k]与a[i]交换*/
}
printf（"thesortednumbers:
＼n"）;
for（i=1;i<11;i++）
printf（"%5d",a[i]）;
}
5.2二维数组的定义和引用
前面介绍的是只有一个下标的数组，称为一维数组，在实际问题中有很多量是二维或多维的。
5.2.1二维数组的定义
二维数组定义一般形式为：
类型说明符数组名[常量表达式1][常量表达式2]；
其中：
常量表达式1为第1维（称为行）下标的长度，常量表达式2为第2维（称为列）下标的长度。
例如，inta[3][4];
说明了一个3行4列的整型数组，数组名为a，元素的个数共有3×4个。
C语言对二维数组采用这样的定义方式，可以把二维数组看作是一种特殊的一维数组：
它的元素又是一个一维数组。
例如，可以把a看作是一个一维数组，它有3个元素：
a[0]、a[1]、a[2]，每个元素又是一个包含4个元素的一维数组。
见图5.1。
可以把a[0]、a[1]、a[2]看作是3个一维数组的名字。
上面定义的二维数组可以理解为定义了3个一维数组，即相当于floata[0][4]，a[1][4]，a[2][4]；
a[0]……a[0][0]a[0][1]a[0][2]a[0][3]——0行
a[1]……a[1][0]a[1][1]a[1][2]a[1][3]——1行
a[2]……a[2][0]a[2][1]a[2][2]a[2][3]——2行
∣│||
0列1列2列3列
图5.1
与一维数组一样，二维数组的下标也是从0开始的，在二维数组中实际上描述了一个3行4列的表格，二维数组中的两个下标自然的形成了表格中的行列对应关系。
而实际上在计算机中，由于存储器是连续编址的，即存储单元是按一维线性排列的，所以二维数组在计算机中是转换成一维数组排列存放的，即先按列号由小到大存放第一行元素，再存放第二行元素……因此，C语言中，二维数组是按行排列的。
C允许使用多维数组。
有了二维数组的基础，再掌握多维数组是不困难的。
例如，定义三维数组的方法是
floata[2][3][4];
多维数组元素在内存中的排列顺序：
第一维的下标变化最慢，最右边的下标变化最快。
5.2.2二维数组元素引用
二维数组元素的一般表示方法为：
数组名[下标][下标]
其中，下标为整型常量或整型表达式，如为小数系统自动取整。
二维数组元素又称双下标变量，和普通变量的使用方法一样，可以出现在表达式中，也可以被赋值，
例如：
b[1][2]=a[2][3]/2；
由于下标变量和数组说明在表示形式上是一样，因此使用时应特别注意。
例如：
inta[3][4]；
…
a[3][4]=2/3；
以上语句中的a[3][4]是完全不同的两个概念，第一个语句中的a[3][4]用来定义一个数组，说明该数组是一个二维整型数组，有3×4个元素；第二个语句中的a[3][4]则是一个双下标变量，是数值a的第4行第5列的一个元素。
5.2.2二维数组的初始化
与一维数组相似，对于二维数组，也可以通过数组初始化给它们赋初值，通常也具有三种方式。
1．按行分段赋初值
例如：
inta[3][4]={{1,2,3,4},{5,6,7,8}{9,10,11,12}};
2．按行连续赋初值
例如：
inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
以上两种初始化方式是完全等价的，比较而言，第一种方式比较清晰明了，有助于阅读程序。
3．部分赋初值，同一维数组一样，未赋值元素自动取0值
例如：
inta[3][3]={{0,1},{0,0,2},{3}};
赋值后的元素值为：
010002300
C语言允许对全部元素赋初值时，可以省略第一维的长度。
例如：
inta[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}；
可以写为：
inta[][4]{1,2,3,4,5,6,7,8,9,10,11,12}；
编译系统在编译程序时通过对初始值表中所包含的元素的个数进行检测，能够自动确定这个二维数组的第一维长度。
在定义时也可以只对部分元素赋初值而省略第一维的长度，但应分行赋初值。
如：
inta[][4]={{0，0，3}，{}，{0，10}};
这样的写法，能通知编译系统；数组共有3行。
数组各元素为
0030
0000
01000
从本节的介绍中可以看到：
c语言在定义数组和表示数组元素时采用a[][]这种两个方括弧的方式，对数组初始化时十分有用，它使概念清楚，使用方便，不易出错。
5.2.4二维数组程序举例
【例5.6】将一个二维数组中的行和列元素互换，存放到另一个二维数组中。
如原数组为：
a=
互换后为：
b=
#include
main（）
{inta[2][3]={{1,2,3},{4,5,6}}；
intb[3][2],i,j;
for（i=0;i<2;i++）
for（j=0;j<3;j++）
b[j][i]=a[i][j];/*对数组a和数组b进行行列元素互换*/
printf（"Arraya:
\n"）;
for（i=0;i<2;i++）/*双重循环输出二维数组a*/
{for（j=0;j<3;j++）
printf（"%4d",a[i][j]）;/*注意数据之间应有间隔*/
printf（"\n"）;/*注意换行*/
}
printf（"Arrayb:
\n"）;
for（i=0;i<=2;i++）/*双重循环输出数组b*/
{for（j=0;j<=1;j++）
printf（"%4d",b[i][j]）;
printf（"\n"）;
}
}
【例5.7】用二维数组实现输入N个学生，M科成绩，
（1）求出每门课的最高成绩
（2）求出所有成绩中的最高者，并记下其所在的行号和列号。
按照本例要求，可以定义一个N行M列的数组存放输入的原始数据，但是这里为了方便，可以把数组定义成N+1行M列，最后一行用于存放每门课的最高成绩，其他每行记录一个学生的M科成绩。
据此写出以下程序：
#defineN4
#defineM5
main（）
{
inta[N+1][M],i,j,row_max,max,row,colum;
printf（“\nPleaseinput4*5data:
\n”）;
for（i=0;ifor（j=0;jscanf（“%d”,&a[i][j]）;
for（j=0;j{row_max=a[0][j];
for（i=1;iif（row_maxa[N][j]=row_max;
}
printf（“Inputteddata:
\n”）;
for（i=0;i{for（j=0;jprintf（“%5d”,a[i][j]）;
printf（“\n”）;}
printf（“Maxofeveryrow:
\n”）;
for（j=0;jprintf（“%5d”,a[N][j]）;
printf（“\n”）;
max=a[0][0];/*先将max 置为a[0][0]*/
row=0;colum=0;/*记下最初max对应的行号和列号*/
for（i=0;ifor（j=0;jif（a[i][j]>max）
{
max=a[i][j];
row=i;
colum=j;
}
printf（"\nmax（ofall）=%d,row=%d,colum=%d＼n",max,row,colum）;
}
5.3字符数组
字符数组是一种用来存放和处理字符型数据的数组变量，字符数组中一个元素存放一个字符。
因为字符数组与前两节所介绍的数值数组在存放和处理数据时的方法有所不同，所以这里单独对其进行讨论。
5.3.1字符数组的定义
字符数组类型说明一般表示形式为：
char数组名[常量表达式]；
char数组名[常量表达式1][常量表达式2]；
例如：
charch1[10]；/*说明ch1为一维字符数组，含有10个元素*/
charch2[5][6]；/*说明ch2为二维字符数组，含有5×6个元素*/
5.3.2字符数组的初始化
字符数组的初始化通常采用的两种方式：
1.逐个给数组中的各元素赋初值
例如：
charch[10]={'C','','P','r','o','g','r','a','m'};
赋值后各元素的值为：
ch[0]ch[1]ch[2]ch[3]ch[4]ch[5]ch[6]ch[7]ch[8]ch[9]
C
P
r
o
g
r
a
m
\0
其中，ch[9]未赋值，系统自动赋空字符（即‘\0’）
当对全部元素赋初值时可以省去长度说明，上式可写为：
charch[]={'C','','P','r','o','g','r','a','m'};
这时数组ch的长度自动定为9。
使用时注意：
若括号中提供的初值个数大于字符长度，系统按语法错误处理；若初值个数小于数组长度，则将字符赋给前面的数组元素，其余元素自动赋空字符（即'\0'）。
2．用字符串直接给字符数组赋初值
在C语言中，将字符串作为字符数组来存放。
上面的初始化语句就是用一个一维的字符数组存放一个字符串“CProgram”中的字符。
这个字符串的实际存储长度与数组长度相等。
有时，人们关心的是有效字符串的长度而不是字符数组的长度。
例如，定义一个字符数组长度为100，而实际有效字符只有40个。
为了测定字符串的实际长度，C语言规定了一个“字符串结束标志”，以字符‘＼0’代表。
如果有一个字符串，其中第10个字符为‘＼0’，则此字符串的有效字符为9个。
也就是说，在遇到字符‘＼0’时，表示字符串结束，由它前面的字符组成字符串。
系统对字符串常量也自动加一个‘＼0’作为结束符。
例如“CProgram”共有9个字符，但在内存中占10个字节，最后一个字节‘＼0’是由系统自动加上的。
字符串作为一维数组存放在内存中。
有了结束标志‘＼0’后，字符数组的长度就显得不那么重要了。
在程序中往往依靠检测‘＼0’的位置来判定字符串是否结束，而不是根据数组的长度来决定字符串长度。
当然，在定义字符数组时应估计实际字符串长度，保证数组长度始终大于字符串实际长度。
如果在一个字符数组中先后存放多个不同长度的字符串，则应使数组长度大于最长的字符串的长度。
我们以前曾用过以下的语句：
printf（"Howdoyoudo?
＼n"）;
即输出一个字符串。
在执行此语句时系统怎么知道应该输出到哪里为止呢?
实际上，在内存中存放时，系统自动在最后一个字符‘＼n’的后面加了一个‘＼0’作为字符串结束标志，在执行printf函数时，每输出一个字符检查一次，看下一个字符是否‘＼0’。
遇‘＼0’就停止输出。
对C语言处理字符串的方法有以上的了解后，我们可以用字符串常量来使字符数组初始化。
例如：
charch[10]={"Cprogram"};或charch[]={"Cprogram"};
也可以省去括号{}，直接写为：
charch[10]="Cprogram";或charch[]="Cprogram";
使用时注意：
对用双引号括起来的字符串常量，C编译系统会自动在其后面加上一字符的结束标志符'\0'。
如上例，编译系统通过计算初值个数自动确定该数组长度为10，其中字符串长度为9，加上结束标志符'\0'。
因此，字符串方式赋初值比逐个字符赋初值要多占一个字节，用来存放字符串结束标志'\0'。
上面的数组ch在内存中实际存放的是：
Cprogram\0。
需要说明的是：
字符数组并不要求它的最后一个字符为‘＼0’，甚至可以不包含‘＼0’。
像以下这样写完全是合法的：
charc[5]={'c'，'h'，'i'，'n'，'a'};
是否需要加‘＼0’，完全根据需要决定。
但是由于系统对字符串常量自动加一个‘＼0’。
因此，人们为了使处理方法一致，便于测定字符串的实际长度，以及在程序中作相应的处理，在字符数组中也常常人为地加上一个‘＼0’。
如：
charc[6]={'c'，'h'，'i'，'n'，'a'，'＼0'};
注意，C语言中，没有专门的字符串变量，通常用一个字符数组来存放一个字符串。
5.3.3字符串的输入与输出
字符串的输入输出有两种方式
1．用格式符"%c"实现逐个字符输入输出。
【例5.8】阅读程序，写出程序结果。
#include
main（）
{chara[4];inti;
printf（"请输入三个字符:
"）;/*从键盘输入单个字符赋给字符串的每个元素*/
scanf（"%c,%c,%c",&a[0],&a[1],&a[2]）;
printf（"输入的字符串是:
"）;
for（i=0;i<3;i++）/*为逐个输出字符设置的循环*/
printf（"%c",a[i]）;/*输出各元素的单个字符*/
}
程序运行结果：
请输入三个字符：
a,b,c
输入的字符串是：
abc
2.用格式符"%s"实现整个字符串输入输出
采用格式符"%s"后，将使字符数组的输入输出变和简单、方便。
【例5.9】用格式符
升级会员 