第4章数组.docx

第4章数组.docx

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

第4章数组

第4章数组

教学内容：

1．一维数组的定义（10分钟）、初始化赋值（10分钟）和元素引用（20分钟）；

2．一维数组求最值、均值（20分钟）与排序（30分钟）的编程方法。

3．二维数组的定义（15分钟）、初始化赋值（10分钟）和元素引用（10分钟）；

4．二维数组元素的输入/输出（15分钟）、求最值、均值问题（40分钟）的编程方法；

5．字符串的概念（8分钟）、字符数组的定义（7分钟）、初始化赋值（15分钟）和引用方法（15分钟）；

6．六种字符串处理函数的格式与功能（30分钟），应用举例（15分钟）；

7．习题课内容

（1）一维有序数组中数据的插入与删除；

（2）二维数组的最值问题、求均值问题；

（3）二维数组的排序；

（4）矩阵加、减、乘法运算；

（5）杨辉三角形问题

教学要求：

1．掌握一维数组定义、初始化赋值和使用方法；

2．学会一维数组求最值、均值与排序的编程方法；

3．掌握二维数组定义、初始化赋值和使用方法；

4．学会二维数组元素的输入/输出、求最值、均值问题的编程方法；

5．掌握字符数组的定义、初始化赋值和使用方法；

6．学会字符串处理函数的使用方法；

7．学会有序数组中数据的插入与删除、二维数组的排序、矩阵加、减、乘法运算、杨辉三角形等问题编程方法。

教学方法：

1．通过线性代数中行矩阵引出一维数组的数组名、数组元素、元素下标等概念，然后给出一维数组的定义及初始化赋值。

2．用数组的内存分配图来说明一维数组的内存分配方式。

3．在介绍一维数组元素引用时，应使用最简单的数组元素输入/输出例子，以便学生能通过简单例子来理解一维数组的概念。

4．一维数组应用重点是：

求数组元素的累加和、平均值、最大值、最小值、排序程序的编写方法。

求最大（小）值的方法是数据元素逐一比较，大（小）的留下，小（大）的放走。

排序算法的关键是要记住：

（1）冒泡法（升序）：

定义数组为a[N]，数据输入到a[0]~a[N-1]，外循环变量i从1到N-1，内循环变量j从0到N-1-i，相邻两数比较，若a[j]>a[j+1]则交换。

（2）选择法（升序）：

定义数组为a[N+1]，数据输入到a[1]~a[N]，用双循环：

i=1toN-1，j=i+1toNifa[i]>a[j]则交换。

（3）用单步运行方法，使学生看清求最值、均值与排序的过程。

建议制作多媒体课件演示排序过程。

5．二维数组的概念可从m*n矩阵及二维线性表引入。

并由此给出定义、初始化赋值。

6．二维数组按行分配存储空间的概念一定要画图说明。

7．二维数组元素引用可用3*4数组数据的输入/输出为例加以说明，举例后再给出思考题，让学生考虑数据处理，如两数组相加的处理。

8．二维数组应用举例以计算学生成绩表中的平均成绩为重点，在此基础上引出计算总分与每门课平均分的问题，再进一步引深到求每门课最高分与最低分的问题。

9．重点讲清字符串的格式、存储方式、结束标志，说明字符数组是类型为字符型的数组，因此，其定义格式与一维数组基本相同。

允许用cin将字符串输入到字符数组，用cout将字符数组输出到屏幕。

10．可以用串函数连接、拷贝、比较两个字符串，测串长，改变大小写等。

11．通过习题课使学生学会下列问题的求解编程

（1）一维有序数组中数据的插入与删除；

（2）二维数组的最值问题、求均值问题；

（3）二维数组的排序；

（4）矩阵加、减、乘法运算；

（5）杨辉三角形问题。

C++除了提供基本数据类型外，还提供了导出数据类型，它们有数组、结构体、共同体和类，本章介绍数组。

数组是若干个同类数据元素的集合，分为一维数组、二维数组、字符数组。

下面依次介绍。

4.1数组的定义和引用

4.1.1一维数组的定义和引用

引例：

在线性代数中具有10个整数元素的行矩阵A表示方法为：

A=[a0a1a2a3…a9]，为了存放行矩阵A的元素值，引入一维整型数组a[10]，该数组的数组名为a，共有10元素，分别为a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]。

一维数组必须先定义后使用，其定义格式为：

inta[10];

表示定义了一个名为a的整型数组，由此可引出一维数组的定义格式。

1.一维数组的定义与初始化赋值

（1）定义格式：

〔存储类型〕<类型><数组名>[<常量表达式>];

说明：

①存储类型将在第5章中介绍；

②类型定义了数组元素的数据类型，可以是基本类型或导出类型；

③数组名应符合标识符的命名规则；

④常量表达式规定了数组元素的个数，即数组长度。

常量表达式中可以包含常量和符号常量，不能包含变量，如N+1。

其中N为符号常量。

⑤数组元素的下标从0开始，且不能超出范围。

（2）一维数组的初始化赋值

一维数组初始化赋值有三种方法：

①给所有元素赋初值：

{a0,a1,a2,…,an}

将各元素初值放在花括号括起的表中，各初值间用逗号分开。

例如：

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

表示数组a中的所有数组元素a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]分别获得初值1、2、3、4、5、6、7、8、9、10。

注意：

可由初值个数确定数组长度。

如果一个数组在定义时对它的所有元素赋了初值，可以不指定数组的长度，系统自动计算数组的长度。

例如：

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

系统自动计算b数组的长度为5，即b数组有5个数组元素b[0]、b[1]、b[2]、b[3]、b[4]，并分别获得初值1、2、3、4、5。

②给部分元素赋初值{a0,a1,a2,…,ak}

将a0、a1、…、ak-1赋给a[0]、a[1]、…、a[k-1],而a[k]、…、a[n]的值不确定。

例如：

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

a[0]

1

a[1]

2

a[2]

3

a[3]

4

a[4]

5

a[5]

6

a[6]

7

a[7]

8

a[8]

9

a[9]

10

图4.1一维数组的存储方式

表示数组a中的前5个元素a[0]、a[1]、a[2]、a[3]、a[4]分别获得初值1、2、3、4、5，其它元素的值是不确定的。

③数组定义为全局或静态变量时，所有数组元素初值均为0；数组定义为其他存储类型的局部变量时，数组元素没有确定的值。

关于局部变量、全局变量、静态变量的概念将在后面的章节中介绍。

2.一维数组内存分配

数组a[n]定义后，系统分配n*k个连续存储单元存放数组元素值（k=元素占用字节数）。

例如：

定义数组:

inta[10]={1,2,3,4,5,6,7,8,9,10};后，系统将为数组a分配10个元素的存储空间，每个元素占有4个字节，共40个字节。

存储空间的分配如图4.1所示。

3.一维数组元素的引用

C++规定只能对数组中的元素进行引用，不能把整个数组作为一个整体使用。

一维数组元素的引用格式：

<数组名>[<下标表达式>]

下标表达式值=数组元素下标（整型）。

【例4.1】通过键盘将10个整数依次输入到一个数组中，然后按倒序输出。

程序如下：

#include

voidmain（void）

{inta[10],i;

cout<<"Inputtenintegers:

";

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

cin>>a[i];//结合图4.1讲述

for（i=9;i>=0;i--）

cout<

cout<

}

程序执行后提示：

Inputtenintegers:

0123456789

9876543210

4.一维数组应用举例

【例4.2】某小组有10个学生，进行了数学考试，求他们数学成绩的平均分、最高分和最低分。

（对应习题4.7,4.13）

分析：

求N个数的平均值的方法是，首先求N个数的累加和，并保存在变量sum中，然后将累加和sum除以数据个数N，即可求得N个数的平均值。

求N个数中的最大值的方法是，首先设变量max，存放第1个数，然后将余下的数按次序分别与max进行比较，若某一数大于max，则将其值赋给max，若某一数小于max，则max的值不变，当余下的数都比较完后，max中存放的就是N个数中的最大值。

求N个数中的最小值的方法同求N个数中的最大值的方法类似，流程图如图4.2所示，程序如下：

#include

#defineN10

voidmain（void）

{floata[N],sum,ave,max,min;

fori=0toN-1

输入a[i]

sum=0

max=a[0]

min=a[0]

fori=0toN-1

sum=sum+a[i]

真

假

max=a[i]

真

假

min=a[i]

ave=sum/N

输出平均值ave、最大值max、最小值min

图4.2求一批数的平均值、最大值、最小值流程图

a[i]>max

a[i]

inti;

cout<<"Inputintegers:

";

for（i=0;i

cin>>a[i];

sum=0;

max=a[0];

min=a[0];

for（i=0;i

{sum=sum+a[i];

if（a[i]>max）

max=a[i];

if（a[i]

min=a[i];

}

ave=sum/N;

cout<<"ave="<

cout<

}

程序运行后，提示：

Inputintegers:

90876892567885909864

输出：

ave=80.8,max=98,min=56

【例4.3】（此例不一定要介绍）将一个数组的内容按颠倒的次序重新存放。

例如数组中数组元素原来的值依次为：

8、3、5、1、9、7、2，要求改为：

2、7、9、1、5、3、8。

分析：

设a数组有n个元素，将a数组中的内容按颠倒的次序重新存放，只需将元素a[0]的内容与元素a[n-1]的内容交换，将元素a[1]的内容与元素a[n-2]的内容交换，……，将元素a[i]的内容与元素a[n-i-1]的内容交换即可；i的取值范围为0到（取整）-1。

例如，将数组内容8、3、5、1、9、7、2改为2、7、9、1、5、3、8的方法如图4.3所示。

程序如下：

#include

a[0]

8

a[1]

3

a[2]

5

a[3]

1

a[4]

9

a[5]

7

a[6]

2

图4.3数组内容倒置

a[0]

2

a[1]

7

a[2]

9

a[3]

1

a[4]

5

a[5]

3

a[6]

8

（a）倒置之前

（b）倒置之后

#include

#defineN7

voidmain（void）

{inta[N],i,temp;

cout<<"Input7integers:

";

for（i=0;i

cin>>a[i];

cout<

for（i=0;i

{temp=a[i];

a[i]=a[N-i-1];

a[N-i-1]=temp;

}

for（i=0;i

cout<

cout<

}

程序执行后提示：

Input7integers：

8351972

2791538

【例4.4】某班有10个学生，进行了数学考试，现要求将数学成绩按由低到高的顺序排序。

（对应习题4.9）

分析：

排序是指将一组无序的数据按从小到大（升序）或从大到小（降序）的次序重新排列。

排序的方法很多，这里介绍两种简单的排序方法—冒泡法和选择法。

（1）冒泡法

333

552

225

666

777

75555

57666

66733

33372

22227

5555

6633

3362

2226

7777

32

23

55

66

77

第1轮比较4次

第2轮比较3次

第3轮比较2次

第4轮比较1次

图4.4冒泡排序法

先举一实例来说明冒泡法排序：

要求将5个数7、5、6、3、2按从小到大的次序排列。

排序方法如图4.4所示。

第一轮第1次将第1个数7和第2个数5进行比较，因7大于5，所以将它们交换，第2次将第2个数7和第3个数6进行比较，因7大于6，所以将它们交换，依次类推共进行5-1=4次，这时，第1轮比较结束，可以看到：

最大的数7已“沉底”，即成为最下面的一个数，而小的数“上升”。

第2轮第1次将第1个数5和第2个数6进行比较，因5小于6，所以不变，依次类推共进行5-1-1=3次（因第5个数已是最大数，所以不必再将第4个数与第5个数进行比较，所以少1次），这时第2轮比较结束，得到3、5、2、6、7的数据序列。

以此类推，第3轮进行2次比较，得到3、2、5、6、7的数据序列。

第4轮进行1次比较，得到2、3、5、6、7的数据序列，完成了排序工作。

所以，对5个数进行排序，要进行4轮比较，在第1轮中要进行4次相邻两个数之间的比较，在第2轮中要进行3次相邻两个数之间的比较，在第3轮中要进行2次相邻两个数之间的比较，在第4轮中只进行1次相邻两个数之间的比较，在比较时，如果前面一个数大于后面一个数，则要交换它们的值，否则就不变。

这样才能使5个数按从小到大的次序排列。

这种排序方法被形象地称为“冒泡法”，在排序的过程中，小的数就象气泡一样逐层上冒，而大的数则逐个下沉。

在程序设计时，可以将这5个数存入到一个数组a中，然后用双重循环来实现其排序操作，外循环用变量i控制轮次，i的值从1到5-1（4），内循环用变量j控制第i轮中比较的次数，j从0到5-1-i。

流程图如图4.5所示，程序如下：

fori=0toN-1

输入a[i]

fori=1toN-1

forj=0toN-i-1

真

假

a[j]与a[j+1]交换

fori=0toN-1

输出a[i]

图4.5冒泡法排序流程图

a[j]>a[j+1]

#include

#include

#defineN10

voidmain（void）

{floata[N],temp;

inti,j;

cout<<"Inputscore:

";

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

cin>>a[i];

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

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

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

{temp=a[j];

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

a[j+1]=temp;

}

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

cout<

cout<

}

程序运行后，提示：

Inputscore:

90786896887567859284

输出：

67687578848588909296

冒泡升序排序算法关键步骤：

定义数组为a[N]，数据输入到a[0]~a[N-1]，用双循环：

i=1toN-1，j=0toN-1-iifa[j]>a[j+1]则交换。

（2）选择法

222

333

765

677

556

75532

57777

66666

33355

22223

2222

7653

6777

5566

3335

22

33

55

76

67

第1轮

第2轮

第3轮

第4轮

图4.6选择排序法

同样，先举一实例来说明选择法排序：

要求将5个数7、5、6、3、2按从小到大的次序排列。

排序方法如图4.6所示。

选择排序法的基本思想是先用求最小值算法找出5个数中的最小数2，将它放在第1个数的位置；然后在余下的4个数中找出最小数3，将它放在第2个数的位置；再在余下的3个数中找出最小数5，将它放在第3个数的位置，以此类推，就能将5个数按从小到大的次序排列好。

具体实现方法是：

第1轮第1次将第1个数7与第2个数5进行比较，因7大于5，所以将它们交换，使第1个数成为5，第2次将第1个数5与第3个数6进行比较，因5小于6，所以保持原状不变。

按此方法进行5-1=4次。

这时第一轮结束，可以看到：

5个数中的最小数2已处在第1个数的位置，得到2、7、6、5、3的数据序列。

第2轮时，因第1个数已是5个数中的最小数，所以不必参与比较，只要将第2个数与其下一个数（即第3个数）到最后一个数（即第5个数）逐一进行比较，若第2个数比后面的一个数大，则要交换它们的值，否则不变，第2轮比较结束时，得到2、3、7、6、5的数据序列；以此类推，共进行4轮比较就可以将5个数按从小到大的次序排列好，得到2、3、5、6、7的数据序列。

一般情况下，将N个数按从小到大的次序排序要进行N-1轮比较，第i轮比较是取出第i个数，让它与其下一个数（即第i+1个数）到最后一个数（即第N个数）逐一进行比较，若第i个数比后面的一个数大，则要交换它们的值，否则就不变。

在设计程序时，可以将N个数存入到一个数组a中，然后用双重循环来实现其排序操作，外循环用变量i作为第i轮比较时取出的第i个数的下标，i的值从1到N-1，内循环用变量j作为与第i个数进行比较的数的下标，j的值从i+1到N。

流程图如图4.7所示，程序如下：

#include

#include

#defineN10

voidmain（void）

{floata[N+1],temp;

fori=1toN

输入a[i]

fori=1toN-1

forj=i+1toN

真

假

a[i]与a[j]交换

fori=1toN

输出a[i]

a[i]>a[j]

图4.7选择法排序流程图

inti,j;

cout<<"Inputscore:

";

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

cin>>a[i];

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

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

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

{temp=a[i];

a[i]=a[j];

a[j]=temp;

}

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

cout<

cout<

}

说明：

本例程序中，定义数组a的长度为N+1，即11，a[0]不用，只用a[1]到a[10]，以符合人们的习惯。

选择升序排序算法关键步骤：

定义数组为a[N+1]，数据输入到a[1]~a[N]，用双循环：

i=1toN-1，j=i+1toNifa[i]>a[j]则交换。

思考题：

若定义数组为a[N]，数据输入到a[0]~a[N-1]，循环变量i、j应如何取值。

提示：

for（i=0;i

for（j=i+1;j

a11a12…a1n

a21a22…a2n

A=…………

am1am2…amn

4.1.2多维数组的定义和使用

二维数组是一个m行n列矩阵。

即：

1.二维数组的定义与初始化赋值

（1）定义格式：

〔存储类型〕<类型><数组名>[][];

其中：

m、n为常量表达式，m=数组行数，n=数组列数。

例如：

inta[3][4];

表示定义了一个3行4列共12个元素的二维整型数组a，数组中各元素分别为：

a[0][0]a[0][1]a[0][2]a[0][3]

a[1][0]a[1][1]a[1][2]a[1][3]

a[2][0]a[2][1]a[2][2]a[2][3]

可以把二维数组看作为一种特殊的一维数组，即它的每一个元素又是一个一维数组。

（2）二维数组的初始化赋值

二维数组初始化赋值的方法有：

①所有元素赋初值

给数组的所有元素赋初值的方法有两种：

方法一：

{{0行初值}，{1行初值}，…，{m行初值}}

即每行一个花括号，花括号间用逗号分隔，全部初值再用一个花括号。

例如：

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

方法二：

{0行初值，1行初值，…，m行初值}

所有初值放在一个花括号中，按数组排列的顺序给各元素赋初值。

例如：

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

注意：

若对所有元素都赋初值，则定义数组时行数可不指定，而列数必须指定。

图4.8二维数组的存储方式

a[0][0]

1

a[0][1]

2

a[0][2]

3

a[0][3]

4

a[1][0]

5

a[1][1]

6

a[1][2]

7

a[1][3]

8

a[2][0]

9

a[2][1]

10

a[2][2]

11

a[2][3]

12

例如：

inta[][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};

②部分元素赋初值

{{0行部分初值}，{1行部分初值}，…，{m行部分初值}}

例如：

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

表示二维数组a的元素a[0][0]、a[0][1]、a[1][0]、a[2][0]、a[2][1]、a[2][2]赋了初值。