第7章 数组.docx

第7章 数组.docx

《第7章 数组.docx》由会员分享，可在线阅读，更多相关《第7章 数组.docx（27页珍藏版）》请在冰豆网上搜索。

第7章数组

第7章数组（Arrays）

【计划课时】授课6课时+上机4课时

7.1一维数组的定义和引用

7.1.1一维数组的定义

同变量一样，数组也必须先定义，后使用。

定义内容：

·数组名（同变量名：

字母、下划线、数字；字母或下划线开头；长度≤32）

·类型（存储属性/数据类型）

·大小（维数/元素个数）

定义的一般形式：

存储属性数据类型数组名[常量表达式][常量表达式]…

[]中为数组长度，用于规定数组元素最大个数；

【注意】数组长度必须是常量表达式——常量或符号常量，其值必须为正，不能为变量。

错误：

正确：

intn=5;#defineN5

inta[n];inta[N];

正确：

inta[10],b[5][4];

charname[8],ch[2][3];

staticfloatx[8*2+1],table[2][3][4];

#defineNUM40;

inta[NUM],b[NUM+2];

7.1.2一维数组元素的引用

常量表达式表示元素的个数,即数组长度.例如在a[5]中,5表示该数组有5个元素,下标从0开始,这5个元素是a[0],a[1],a[2],a[3],a[4].注意不能使用数组元素a[5].

相同类型的数组或变量可以在一个类型说明符下一起说明,互相之间用逗号隔开.例如:

inta［5］,b[10],i；

数组元素只能逐个引用而不能一次引用整个数组

引用数组元素要注意下标不要出界（编译程序不检查是否“出界”）。

讨论：

如果下标值小于0或超过数组长度时会出现什么情况？

例：

main（）

{

inta=1,b[5],c=2,i;

for（i=0;i<=5;i++）

b[i]=i;

printf（“%d,%d\n”,a,c）;

}

运行程序或单步执行观察变量变化情况可以看到，变量c的值因数组越界被破坏了。

比较：

错误正确

（1）inta[3];inta[3]={1,2,3};

a[3]={1,2,3};或inta[]={1,2,3};

a={1,2,3};或inta[3];a[0]=1,a[1]=2,a[2]=3;

（2）intn;inta[5];

scanf（“%d”,&n）;for（i=0;i<5;i++）

inta[n];printf（“%d\n”,a[i]）;

定义时不可用变量作下标引用时可以用整型变量及表达式作下标

数组长度必须是整型常量及其表达式，不得为变量，而数组元素下标可以是变量！

7.1.3一维数组的初始化

可以在程序运行后用赋值语句或输入语句使数组中的元素得到值，也可以使数组在程序运行之前（即编译阶段）就得到初值，后者称为数组的初始化。

对数组元素的初始化可以用以下方法实现:

1.在定义数组时对数组元素赋以初值，如：

ints［5］={78,87,77,91,60};

2.也可以只给一部分元素赋值。

例如：

ints［5］={78,87,77};

其结果是：

s［0］=78，s［1］=87，s［2］=77，s［3］=0，s［4］=0，即花括号内的值只赋给了数组的前几个元素，后几个元素的值为0。

3.如果想使一个数组中全部元素值为0,可写成:

ints[5]={0,0,0,0,0};或ints[5]={0};

不能写成:

ints[5]={0*10};（不能给数组整体赋初值）

4.若对全部数组元素赋初值时，可以不指定数组长度。

例如:

ints［5］={1,2,3,4,5};可以写成:

ints［］={1,2,3,4,5};（系统自动定义数组长度为5）

但若被定义的数组长度与提供的初值的个数不等,则数组长度不能省略.如想定义数组长度为10,而初值只有5个,则数组长度不能省略,必须写成:

inta[10]={1,2,3,4,5};

5.一维数组元素是按下标递增的顺序连续存放的，即数组占有连续的存贮空间。

如a数组在内存中的存贮示意如图所示。

a[0]

a[1]

a[2]

a[3]

a[4]

7.1.4一维数组的程序举例

与数值数组有关的常用算法

·排序：

起泡法/选择法/插入法

·查找：

顺序查找法/折半查找法

1、常用排序算法

①起泡法（冒泡法/气泡法）P124

有n个杂乱无序的数，要求将这n个数从小到大（或从大到小）排序后输出。

【例一】设n=5。

排序示意图如下：

第1轮（i=1）

○○○○○

比4次

第2轮（i=2）

○○○○○

比3次

第3轮（i=3）

○○○○○

比2次

第4轮（i=4）

○○○○○

比1次

共需进行n-1=4轮

从第1个开始，两两比较，大者交换到后面（右边）。

每轮从第1个比到第n-i个

这种排序方法之所以叫“冒泡法”，是因为在排序过程中，较小的数象气泡一样逐渐往前冒（向上冒），大的数逐渐向后沉，最终完成排序。

流程图和程序如下：

#defineN5

main（）

{

inti,j,t,a[N+1];

for（i=1;i<=N;i++）

scanf（"%d",&a[i]）;

for（i=1;i<=N-1;i++）

for（j=1;j<=N-i;j++）

if（a[j]>a[j+1]）

{

t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

for（i=1;i<=N;i++）

printf（"%d",a[i]）;

}

②选择法

从算法优化的角度对“冒泡法”进行改进。

冒泡法每一轮都要将数组中的数两两比较,并根据大小交换之——效率低。

选择法改进处：

两两比较后并不马上交换，而是找到最小数后记下其下标。

在一轮比较完毕后，再将最小的数一次交换到位。

——比较次数不变，交换次数减少。

流程图如下：

程序如下：

（设要求排序的数列为5,10,-7,3,7共5个数，要求升序排列）

法1：

从左到右依次从小到大排放

#defineN5

main（）

{inti,j,t,p,a[N+1]={0,5,10,-7,3,7};

for（i=1;i<=N-1;i++）

{p=i;

for（j=i+1;j<=N;j++）

if（a[p]>a[j]）p=j;/*<号为降序*/

if（p!

=i）

{t=a[p];a[p]=a[i];a[i]=t;}

}

for（i=1;i<=N;i++）

printf（"%d",a[i]）;

printf（"\n"）;

}

法2：

从右到左依次从大到小排放

#defineN5

main（）

{inti,j,t,p,a[N+1]={0,5,10,-7,3,7};

for（i=1;i<=N-1;i++）

{p=N-i+1;

for（j=1;j<=N-i;j++）

if（a[j]>a[p]）p=j;/*<号为降序*/

if（p!

=N-i+1）

{t=a[p];a[p]=a[N-i+1];a[N-i+1]=t;}

}

for（i=1;i<=N;i++）

printf（"%d,",a[i]）;

printf（"\n"）;

}

③插入法

如果有N个元素，也是要比较N-1轮，但每轮取第i个（i从1开始）元素的值为暂存值m，然后与左边的各数（从j=i-1开始）比较一直到左边第一个（j=0）为止。

如果m比左边大，就让左边的值右移，最后将该轮的第i个数插到左边的合适位置（如果它比较大的话）。

注意：

第一轮后，左边的数总是从大到小排列的，只有当第i个数大于左边的数时，才会发生交换。

main（）

{inta[5]={4,7,2,5,1};

inti,j,m;

for（i=1;i<5;i++）

{m=a[i];

j=i-1;

while（j>=0&&m>a[j]）

{a[j+1]=a[j];

j--;

}

a[j+1]=m;

}

for（i=0;i<5;i++）

printf（"%d",a[i]）;

printf（"\n"）;

}

结果：

75421（插入排序——降序）

【讨论】如果要求升序（结果为12457）呢？

while（j>=0&&m

2、查找

①顺序查找法（《试题汇编》【6.92】及【6.93】）

【例一】《试题汇编》【6.92】

下面程序用“顺序查找法”查找数组中是否存在某一关键字。

main（）

{

inta[8]={25,57,48,37,12,92,86,33};

inti,x;

printf（"请输入要查找的数x="）;

scanf（"%d",&x）;

for（i=0;i<8;i++）

if（x==a[i]）

{

printf（"找到了!

是第%d个元素。

\n",i）;

break;

}

if（i==8）

printf（"没找到!

\n"）;

}

【例二】《试题汇编》【6.93】快速顺序查找法

main（）

{

inta[9]={25,57,48,37,12,92,86,33};

inti,x;

printf（"请输入要查找的数x="）;

scanf（"%d",&x）;

a[8]=x;

i=0;

while（a[i]!

=x）i++;

if（i<8）

printf（"找到了!

是第%d个元素。

\n",i）;

elseprintf（"没找到!

\n"）;

}

②折半查找法（《试题汇编》【6.90】、【6.91】及【7.22】）

前提：

数据已按一定规律（升或降序）排列好。

思路：

先检索当中的一个数据是否所需，如不是，判断要找的数据在哪一边，缩小范围后再按同样方法继续检索，直到找到或找遍。

方法：

设要找的数为x，n+1个数据已排好序存放在数组a中。

a.设low=0，high=n

b.mid=（low+high）/2

c.if（x==a[mid]）找到了；

elseif（x>a[mid]）说明x在右边，让low=mid+1；

else说明x在左边，让high=mid-1

d.重复b和c两步操作，直到x=mid（找到）或low>high（找遍了）为止。

程序：

main（）

{

inta[9]={6,12,18,42,44,52,67,94,99};

intlow=0,mid,high=8,x;

clrscr（）;

printf（"请输入要查找的数x="）;

scanf（"%d",&x）;

do{

mid=（low+high）/2;

if（x==a[mid]）

{

printf（"找到了!

是第%d号元素。

\n",mid）;break;

}

elseif（x>a[mid]）low=mid+1;

elsehigh=mid-1;

}while（low<=high）;

if（low>high）printf（"没找到!

\n"）;

}

7.2.二维数组的定义和引用

7.2.1二维数组的定义

二维数组的定义形式为

类型标识符数组名［常量表达式］［常量表达式］;例如，inta[3][2];

表示数组a是一个3×2（3行2列）的数组，共有6个元素，每个元素都是int型。

二维数组的应用之一是矩阵和行列式。

其中，左起第一个下标表示行数，第二个下标表示列数。

我们也可以把二维数组看成是一种特殊的一维数组：

它的元素又是一个一维数组。

例如，可将以上的a数组看成是一个一维数组，它有3个元素，分别是a［0］，a［1］，a［2］，每个元素又是一个包含2个元素的一维数组，如图6.2所示，因此可以把a［0］，a［1］，a［2］看作是三个一维数组的名字。

上面定义的二维数组就可理解为定义了三个一维数组，即相当于

C语言中,二维数组中元素排列的顺序是:

按行存放,即在内存中先顺序存放第一行的元素,再存第二行的元素.

7.2.2二维数组的引用（使用数组元素）

原则：

先定义后引用

只能逐个引用数组元素，不能一次引用整个数组。

每个数组元素均可按一个简单变量的方式进行处理（如参加运算、赋值等）。

引用示例：

a[2][3]=2；（下标为常量）

a[i][j]=20;（下标为为int型变量i,j）

a[i-1][j*3-1]=1（下标为一个复杂的整型表达式）

错误：

a[2,3]

引用数组元素要注意下标不要出界（编译程序不检查是否“出界”）。

7.2.2二维数组的初始化P127

1.对二维数组元素赋初值，可以用分行赋值的方法，例如：

inta［3］［2］={{1,2},{3,4},{5,6}};

其中内{}代表一行元素的初值。

经过如此的初始化后，每个数组元素分别被赋以如下各值：

a［0］［0］=1，a［0］［1］=2，a［1］［0］=3，

a［1］［1］=4，a［2］［0］=5，a［2］［1］=6

写成行列式形如：

12

34

56

2.可以只为数组的部分元素赋值

例如：

inta［3］［2］={{1},{2,3},{4}};

这样，数组的前几个元素的值为：

a［0］［0］=1，a［1］［0］=2，a［1］［1］=3，

a［2］［0］=4而其余元素的初值将自动设为0。

3.在初始化时，也可将所有数据写在一个花括号内，按数组的排列顺序对各元素赋初值。

如：

inta［3］［2］={1,2,3,4};

其结果是:

a［0］［0］=1，a［0］［1］=2，a［1］［0］=3，

a［1］［1］=4，其余元素的值自动设为0。

4.若对全部元素都赋初值，则定义数组时对第一维的长度可以不指定，但对第二维的长度不能省。

如：

inta［3］［2］={1,2,3,4,5,6};

等价于:

inta［］［2］={1,2,3,4,5,6};

系统会根据数据总个数分配空间,一共6个数据,每行2列,当然可

确定为3行.

【例一】以下程序的运行结果是什么？

123

450

600

000

main（）

{

inta[][3]={{1,2,3},{4,5},{6},{0}};

printf（"%d,%d,%d\n",a[1][1],a[2][1],a[3][1]）;

}

结果：

5，0，0

【例二】若inta[][3]={1,2,3,4,5,6,7}，则a数组的第一维大小是多少？

（3）

说明：

静态/外部数组未初始化，默认初值是0（数值）或空格（字符）

auto数组未初始化，初值为某个随机数。

7.2.4二维数组程序举例

【例一】

下列程序的功能是显示如下图形：

10000

21000

32100

43210

54321

main（）

{inta[5][5],i,j;

clrscr（）;

a[5][5]分析:

a00a01a02a03a04

a10a11a12a13a14

a20a21a22a23a24

a30a31a32a33a34

a40a41a42a43a44

for（i=0;i<5;i++）

{for（j=0;j<5;j++）

{if（【6】）a[i][j]=0;

elsea[i][j]=【7】;

printf（"%3d",a[i][j]）;

}

printf（"\n"）;

}

}

答案：

【6】i

【分析】这类题的元素值排列很有规律，所以一般要从分析行数i、列数j与元素值的关系着手。

分析上图可知，当i=j时，元素值随行数i增加而增加，随列数j增加而减小，这样就很容易得出其元素值与i,j的关系是i+1-j。

矩阵运算（《试题汇编》【6.74】、【6.75】、【6.77】、【6.84】、【6.85】及【6.86】等）

【例二】有一3×4矩阵，编程求其元素最大值并输出其行、列号。

main（）

{inti,j,x,y,max;

inta[][4]={3,5,8,1,6,9,7,12,-6};

max=a[0][0];

3581

69712

-6000

for（i=0;i<3;i++）

for（j=0;j<4;j++）

if（a[i][j]>max）

{max=a[i][j];

x=i;

y=j;

}

printf（"maxisa[%d][%d]=%d\n",x,y,max）;

}

结果：

maxisa[1][3]=12

要点：

用两重循环遍历所有元素。

【讨论】如果求最小值？

（a[i][j]

【例三】求矩阵a、b乘积，结果存入矩阵c中并按矩阵形式输出。

（《试题汇编》【6.85】）

【说明】矩阵相乘的规则：

一个m×p矩阵A=（aij），可以右乘一个p×n矩阵B（bij）,得到一个m×n矩阵C（cij）,其中：

（i=1,2,…,m，j=1,2,…,n）

a11a12…a1p

a21a22…a2p

…

am1am2…amp

A=

b11b12…b1n

b21b22…b2n

…

bp1bp2…bpn

B=

c11c12…c1n

c21c22…c2n

…

cm1cm2…cmn

C=

main（）

{

inta[3][2]={2,-1,-4,0,3,1};

intb[2][2]={7,-9,-8,10};

inti,j,k,s,c[3][2];

for（i=0;i<3;i++）

for（j=0;j<2;j++）

{

for（k=s=0;k<2;k++）

s+=a[i][k]*b[k][j];

c[i][j]=s;

}

for（i=0;i<3;i++）

{for（j=0;j<2;j++）

printf（"%6d",c[i][j]）;

printf（"\n"）;

}

}

结果：

数组a:

2-1

-40

31

数组b:

7-9

-810

数组c:

22-28

-2836

13-17

7.3字符数组

【字符数组】存放字符（每个数组元素存放一个字符）P130

7.3.1字符数组的定义

如：

chara[10];chara[2][3];

字符数组——各个元素分别存放一个字符的数组。

字符串——“……”（字符串常量）以“\0”结尾

【注意】字符数组与字符串的区别：

字符串存放在字符数组中，但字符数组与字符串可以不等长；字符串以“\0”结尾。

即：

C语言中无字符串变量，但可用一个字符数组存放字符串；反之，存放在字符数组中的并非都是字符串。

【“\0”】“\0”是指ASCII代码为0的字符。

它既不是一个普通的可显示字符，也不是一个具有操作功能的字符，而是一个“空操作”字符。

它不进行任何操作，在字符数组中仅作字符串结束标记使用。

“\0”可以用赋值方法赋给一个字符变量或字符型数组中的某个元素，如c[8]=“\0”。

运算时，按0（NULL）看待。

如：

#include

main{printf（“%d,%d,%d,%d”,NULL,NULL-100,’\0’,’\0’-100）;}

结果：

0，-100，0，-100

7.3.2字符数组的初始化及引用

单字符方式chara[10]={‘A’,‘B’,‘C’,‘D’};

charb[2][3]={‘A’,‘B’,‘C’,‘D’,‘E’,’F’};

【注意】如果初值个数小于数组长度，则多余的数组元素自动为空字符（’\0’）P130

字符串方式chara[5]={“ABCD”};charc[]=”ABCD”;

chara[2][5]={{‘A’,’B’,’C’,’\0’},{‘x’,’y’,’\0’}};

chara[2][5]={“ABC”,”XY”};

二维字符数组可以认为由若干个一维字符数组（字符串）组成。

【例一】比较以下字符数组长度是否相同：

chara[]=”ABCD”;（5）

charb[]={“ABCD”};（5）

charc[]={‘A’,’B’,’C’,’D’};（4）

7.3.4字符串和字符串结束标志

字符串常量是用双引号括起来的字符序列。

在C语言中，没有字符串变量，字符串是作为一维字符数组来处理的。

在处理字符数组时，为了测定数组中实际存放的字符个数，C语言规定了一个“字符串结束标志”，用字符′\0′代表（其ASCII码值为0，是一个“空操作符”,即无任何操作），也就是说，一个字符串是由有效字符，加上字符′\0′组成的。

系统对字符串常量也自动加一个′\0′作为结束符。

例“string”共有6个字符，但在内存中占7个字节，最后一个字节存放′\0′。

需要提醒读者注意字符串与字符的区别：

“0”为一字符串，在内存中占两个字节，而‘0’为字符，只占一个字节，其ASCII码值为48。

为了方便处理字符数组，C语言还允许用一个简单的字符串常量来初始化一个字符数组，而不必使用一串单个字符。

如:

charc［］={"string"};

或charc［］=″string″；（省略花括号）

经过上述初始化后，c数组中每个元素的初值如下：

c［0］=′s′，c［1］=′t′，c［2］=′r′，c［3］=′i′，c［4］=′n′，c［5］=′g′，c［6］=′\0′

应注意的是，字符串常量的最后由系统自动在末尾加上结束字符′\0′，所以c数组有7个元素。

但若如上节逐个元素初始化，则要显式加′\0′.

即charc［］={′s′,′t′,′r′,′i′,′n′,′g′,′\0′};

而与charc［］={′s′,′t′,′r′,′i′,′n′,′g′};是不同的.

【例一】下列程序段的运行结果是：

（ab）

chara[5]={‘a’,’b’,’\0’,’d’,’\0’};

printf（“%s”,a）;/*如果printf（“%s”,a+1）;结果是b*/

说明：

%s的作用是输出一个字符串，直到遇到’\0’为止。

注意：

在二维数组中，双下标引用——某行某列的某个元素

单下标引用——某行的字符串

【例二】分析以下程序的运行结果：

main（）{

charword[3][10];

inti;

for（i=0;i<3;i++）

scanf（"%s",word[i]）;

p