0.问题引入
定义一个整型变量
int a；
如果要你来定义100个整型变量
int a0,a1,a2,a3,...,a100
很显然，上面的方法不是很聪明的样子
有没有一种办法，让我们一次定义一组相同类型的变量呢？
=>数组
1.什么是数组？
一组具有相同类型的数据元素的有序集合
有序：一段有序的存储空间
在c语言中，数组：
一维数组
二维数组
三维数组
....
其实，C语言中只有一维数组
2.一维数组
2.1定义格式
如：
int a10;
//a0 a1 ...a9
类型说明符 数组名整型表达式；
or
类型说明符 数组名整型表达式 = {初始化列表}；
"类型说明符"：指定数组中每一个元素的类型，不是数组的类型！！！
可以是c语言中任意合法的类型（基本类型，构造类型，指针类型）
typeof(a0) => int:数组中元素的类型
typeof (a) => int10 :整个数组的类型
"数组名" ：
对象的名字，"标识符"
给数组取名字的时候，要符合C语言标识符的规定
整型表达式：
指定数组中数据元素的个数。
C语言规定在定义数组时，需要指定（隐含指定-编译器可以推断出）数组元素的个数
"常量表达式"
int a = 5;
int ba;//以前不能够通过编译的，现在ubuntu优化了。
建议大家在定义数组的时候，还是使用常量表达式。
例子：
int a5;//定义一个数组，数组名为a，里面有5个int类型的元素
int是数组元素的类型，并不是数组a的类型
2.2一维数组的引用
int a10;//定义了一个数组，数组名为a，里面含有10个int类型的元素
如何来访问（引用）这些元素呢？
引用数组元素：
数组名下标
"下标" ：C语言规定数组元素的下标是从0开始
0，1，2，3，4，...，n-1（n是表示，数组有n个元素）
引用数组元素和引用普通变量是一模一样的。
数组元素也是有左值和右值。
int a10;
int b;
a0 = 1024; //把数值1024赋值给元素a0
//a0代表元素a0的地址，把数值1024
存放到a0的地址中去。
b = a0;//把a0的值赋值给b，a0代表元素a0的值（右值）
2.3一维数组在内存中的存放
在C语言中，用一组连续的存储空间，从低地址到高地址
依次存放数组中的每一个元素。
如;
int a10;
a0-------0x3000
a1-------0x3004
练习;
1.请大家写一个程序，验证一下，数组的存储方式
int a5;
&a0 ==>取元素a0的地址；
printf("%p\n",&a0);
printf("%p\n",&a1);
.....
完整的C语言代码;
#include <stdio.h>
int main()
{
int a5;
for(int i =0;i<5;i++)
{
printf("%p\n",&ai);
}
}
2.定义一个一维数组，通过键盘来给每一个元素赋值
再依次输出数组中元素的值。
#include <stido.h>
int main()
{
int a5;
for(int i = 0;i<5;i++)
{
scanf("%d",&ai);
}
for(int i=0;i<5;i++)
{
printf("%d\n",ai);
}
}
2.4 一维数组的初始化
类型说明符 数组名 整型表达式 = {初始化列表}；
初始化： 是指定义对象时，就指定对象的值。
数组的初始化使用{}
例子;
int a5;
printf("%d\n",a0);//undefine 未知的
（1）在定义一个数组时，给每一个元素进行初始化
int a10 = {0,1,2,3,4,5,6,7,8,9};
（2）可以只对前面的元素进行初始化，后面的元素会自动初始化为0
int a10 = {1,2,3};
a0 =1;
a1 = 2;
..
a3 = 0;
....
a9 = 0;
int a10 = {0};//将数组中的每一个元素都初始化为0
（3）如果对全部元素都赋初始值，在定义数组的时候，可以不指定数组的长度（元素个数）
编译器可以自己推断出你有多少个元素
int a\[\] = {1,2,3,4,5};
===>
int a5 = {1,2,3,4,5};
int a\[\]={0};
===>
int a1 ={0};
NOTE:只有在定义数组时，指定数组全部元素的值
只能在初始化时，给数组整体赋值
int a5 = {1,2,3,4,5};//OBJK
int a5;
a5 = {1,2,3,4,5};//ERROR
a = {1,2,3,4,5};//ERROR
练习：
1.定义一个一维数组，并从键盘随机输入每一个元素的值，
求该一维数组的元素之和，最大值，最小值。
#include <stdio.h>
int main()
{
int a10;
int i;
int sum =0;
for(i=0;i<10;i++)
{
scanf("%d",&ai);
}
int max =a0;
int min = a0;
for(i=0;i<10;i++)
{
sum += ai;
if(ai>max)
{
max = ai;
}
if(ai<min)
{
min = ai;
}
}
printf("sum = %d,max=%d,min=%d\n",sum,max,min);
}
2.判断一个一维数组是否递增
思路：
a0<=a1<=a2<=....an-1
只要找到一个》符号，那么就能证明这个数组就不是递增。
ai PK ai+1
#include <stdio.h>
int main()
{
int a10;
int i;
for(i=0;i<10;i++)
{
scanf("%d",&ai);
}
int flag =0;// 0 -递增；1- 不是递增
for(i=0;i<9;i++)
{
if(ai>ai+1)
{
flag = 1;
break;
}
}
if(flag==1)
{
printf("NO");
}
if(flag==0)
{
printf("YES");
}
}
3.排序的问题
把数组中的每一个元素按一定的规律（升序或降序）放置到合适的位置上面去。
冒泡排序 <-----
希尔排序
快速排序
选择排序 <-----
插入排序
堆排序
.....
冒泡排序：
相邻的两个元素，两两比较，把较大者往后移（升序）
"两两比较"
假设有N个元素：
第0趟排序：
if(a0>a1)
a0<->a1
if(a1>a2)
a1<->a2
if(aN-2>aN-1)
aN-2<->aN-1
序列中，最大值已经保存到aN-1
=>
i来表示数组元素的下标
所以：要比较的式子可以用i来替代
if(ai>ai+1)
ai<->ai+1
for(i=0;i<N-1;i++)
{
if(ai>ai+1)
{
int temp;
temp = ai;
ai = ai+1;
ai+1 = temp;
}
}
第一趟排序：
if(a0>a1)
a0<->a1
if(a1>a2)
a1<->a2
if(aN-3>aN-2)
aN-3<->aN-2
此时，序列中，第二大的值已经保存在aN-2
=>
i来表示数组元素的下标
所以：要比较的式子可以用i来替代
if(ai>ai+1)
ai<->ai+1
for(i=0;i<N-2;i++)
{
if(ai>ai+1)
{
int temp;
temp = ai;
ai = ai+1;
ai+1 = temp;
}
}
只需要将上面的冒泡，进行N-1趟，就可以把所有的元素都放置在合适的位置上面
每一趟冒泡的代码形式都一样的，所以说，只要将上面的代码，想办法让他循环N-1，
那么整个序列就有序了嘛！！！
for(m=0;m<N-1;m++) //冒泡趟数 N:代表的是数组元素个数
{
for(i=0;i<N-1-m;i++)//数组下标范围
{
if(ai>ai+1)
{
int temp;
temp = ai;
ai = ai+1;
ai+1 = temp;
}
}
}
printf();
m 用来标记第m趟冒泡 第m趟冒泡要比较多少次
m = 0 N-1(i<N-1)
m = 1 N-2(i<N-1-1)
m = 2 N-3(i<N-1-2)
m = x N-1-x(i<N-1-m)
选择排序
（1）选择一个最大的元素（遍历数组）
（2）把最大的元素与最后面一个位置的元素进行交换
times =1：表示第一次选择排序
int max = a0;
int max_i = 0;
for(i=0;i<N;i++)
{
if(ai>max)
{
max = ai;
max_i = i;
}
}
if(max_i ！=N-1)
{
amax_i<->aN-1;
}
times = 2:表示第二次选择排序
int max = a0;
int max_i = 0;
for(i = 0;i<N-1;i++)
{
if(ai>max)
{
max = ai;
max_i = i;
}
}
if(max_i !=N-2)
{
amax_i<-->aN-2;
}
times = t:表示第t次交换
int max = a0;
int max_i = 0;
for(i = 0;i<N-t+1;i++)
{
if(ai>max)
{
max = ai;
max_i = i;
}
}
if(max_i != N-t)
{
amax_i<-->aN-t;
}
第几次选择交换 数组下标的范围 交换位置
times = 1 i<N N-1
times = 2 i<N-1 N-2
.....
times = t i<N-t+1 N-t
最多需要选择交换N-1次
for(t=1;t<N;t++)
{
int max = a0;
int max_i = 0;
for(i = 0;i<N-t+1;i++)
{
if(ai>max)
{
max = ai;
max_i = i;
}
}
if(max_i != N-t)
{
amax_i<-->aN-t;
}
}
4.查找一个元素
在数组aN查找一个元素x，如果找到了就返回下标，没有找到就返回-1
（1）查找可以用"遍历"
for(i=0;i<N;i++)
{
if(ai==x)
{
return i;
}
}
return -1;
（2）在一个有序数组中查找，用遍历，就显得有点LOW。
"二分查找法"/"折半查找法"
练习：
在一个有序的数组中，去查找一个值为x的元素
找到了就打印其下标，没有找到，那么打印：没有此元素 4
int L,R;
int aN;
int i,x;
for(i=0;i<N;i++)
{
scanf("%d",&ai);
}
scanf("%d",&x);
L = 0;
R = N-1;
while(L<=R)
{
mid =(L+R)/2;
if(amid<x)//x比中间元素大，所以舍弃mid以及它左边的
{
L = mid +1;
}
else if (amid>x)//x比中间元素小，所以舍弃mid以及它右边的
{
R = mid -1;
}
else
{
printf("x=>%d\n",mid);//mid表示下标
}
}
//没有找到值为x的那一个元素
总结：
1.数组概念问题
2.一维数组
2.1 定义
2.2 数组元素的引用
2.3 数组元素的存储问题
2.4 数组的初始化
3.排序
冒泡
选择
时间复杂度：o（n^2）
4.二分查找法
练习：
1.求斐波拉契数列的前20项之和
斐波拉契数列
1 1 2 3 5 8 13 21
ai = ai-1+ai-2
S1: 先求第i项 =>ai
S2: 累加sum +=ai
int a20 = {0};
a0 = a1 = 1;
sum = a0+a1;
for(i=2;i<20;i++)
{
ai = ai-1 + ai-2;
sum +=ai;
}
2.不用排序，把一个数组中的负数放置数组的前面
如;
2 4 -3 5 -4 8 -2
-2 -3 -1 1 2 3 4
i
思路：
用一个i来记录负数存放的下标
用j来遍历数组，遇到负数，那么就交换
ai<--->aj
i++,
继续从下标为j的地方遍历数组
int aN;
i = 0; //存放负数的下标
for(j=0;j<20;j++)
{
if(aj<0) //交换位置，并且i+1
{
ai<->aj;
i++;
}
}
3.不用排序，求数组中第二大的那一个元素的值（只能遍历一次）
思路;
int max;
int max_2；
max = a0>a1?a0:a1;
max_2 = a0>a1?a1:a0;
for(i=2;i<N;i++)
{
if(ai>max)
{
max_2 = max;
max = ai;
}
else
{
if(ai>max_2)
{
max_2 = ai;
}
}
}
回顾一下，一维数组
定义格式：
元素类型 数组名数组元素的个数；
例子：
int a4;//定义了一个数组，数组名为a，里面有4个int类型的元素。
//在定义数组a的时候，也声明了一个新类型
"像a这样的类型"
typeof(a) =》int 4
a0 int
a1 int
问题： 定义3个像a这样类型的变量，该如何定义
元素类型 数组名 数组元素个数
typeof(a) b 3;
==> int 4 b3;
==> int b34; //二维数组
b的含义：b是一个数组，里面含有3个int4类型的元素
5.二维数组
由上面的推导过程可以得出
c语言中，二维数组实际上就是一个一维数组，只不过该一维数组中的每一个元素
又是一个一维数组
例子： int b34
<=>int4 b3;
数组名为b，里面有三个元素
b0 _ _ _ _》里面含有4个int类型的元素,b0又是一个数组，数组名b0
b1 _ _ _ _》里面含有4个int类型的元素,b1又是一个数组，数组名b1
b2 _ _ _ _》里面含有4个int类型的元素,b2又是一个数组，数组名b2
矩阵角度来看;
三行四列
5.1二维数组的定义格式
从矩阵角度来说
类型说明符 数组名行数列数
连续的存储空间，从低地址到高地址
按行存放，先顺序存放第0行的元素，然后再存放第一行的元素
练习：
1.请大家，来验证一下，二维数组的元素存储方式
#include <stdio.h>
int main()
{
int a34;
i = 0;
a0 _ _ _ _
printf("%p\n",&a00)
printf("%p\n",&a01)
printf("%p\n",&a02)
printf("%p\n",&a03)
for(j=0;j<4;j++)
{
printf("%p\n",&a0j)
}
i = 1;
a1 _ _ _ _
printf("%p\n",&a10)
printf("%p\n",&a11)
printf("%p\n",&a12)
printf("%p\n",&a13)
for(j=0;j<4;j++)
{
printf("%p\n",&a1j)
}
....
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
printf("%p\n",&aij);
}
}
}
2.从键盘按行来给二维数组的每一个元素赋值，然后按列打印输出每个数组元素的值
1 2 3 4
5 6 7 8
9 10 11 12
#include <stdio.h>
#define M 3
#define N 4
int main()
{
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
scanf("%d",&aij);
}
}
for(j=0;j<4;j++)
{
for(i=0;i<3;i++)
{
printf("%d\n",aij);
}
}
}
1.2二维数组的引用
数组元素的引用：
数组名下标
例子: int a34;
//int4 a3
a0 _ _ X _ //a0是一个数组名，里面含有4个int类型的元素
a1 _ _ _ _
要访问上面的元素X，该如何访问？
数组名下标
a02 <==>X
以矩阵的角度：
数组名行号列号
a02
引用二维数组的元素和引用普通变量是一模一样，
它也有左值和右值之分
例子：
a02 = 1024; //把数值1024，写到a02的存储空间中去（变量的地址）
int b = a02;//把a02的值，赋值给b（变量的值）
scanf("%d",&a02)
printf("%d\n",a02);//右值
printf("%p\n",&a02);//左值
1.3二维数组元素的存放
连续的存储空间，连续的存储空间，从低地址到高地址
按行存放，先顺序存放第0行的元素，然后再存放第一行的元素
1.4二维数组的初始化
在定义二维数组时，可以指定每个元素或部分元素的初始值。
(1)分行给二维数组赋初值
int a34 = {{1,2,3,4},
{5,6,7,8},
{9,10,11,12}
}
(2)将所有二维数组的初始值写在一个{}内，
按数组的排列顺序一一对应各个元素
int a34 = {1,2,3,4,5,6,7,8,9,10,11,12};
a00 = 1;
a10 = 5;
a23 = 12;
a20 = 9;
#define M 3
#define N 4
int aMN
===>int a34
a34,很显然越界了！！！（段错误）
(3)对部分元素赋初始值，其余的元素自动置0
int a34={{1,2},{5},{9,10,11}};
<=> {{1,2,0,0},{5,0,0,0},{9,10,11,0}};
(4)如果对全部元素都赋初始值，则定义二维数组时，对一维数组的长度可以省略
但是第二维的长度不能省略
int \[\]4 = {1,2,3,4,5,6,7,8,9,10,11};
NOTE:
只有在数组定义时，才能对数组整体赋值。
练习;
1.定义一个二维数组，将数组中的元素随机进行初始化，然后要求该二维数组
的所有元素之和，最大值，最小值。
2.把一个二维数组，行列互换
1 2 3 4 1 5 9
5 6 7 8 2 6 10
9 10 11 12 ===> 3 7 11
4 8 12
#include <stido.h>
#define M 3
#define N 4
int aMN = {1,2,3,4,5,6,7,8,9,10,11,12};
int bNM;
for(int i =0;i<N;i++)
{
for(int j = 0;j<M;j++)
{
bij = aji;
}
}
//按行输出b
for(int i =0;i<N;i++)
{
for(int j = 0;j<M;j++)
{
printf("%d ",bij);
}
printf("\n");
}
3.实现矩阵乘法
AMK * BKN = CMN
{1 2 4 { 1 2 7（1*1 +2*3 +4*0） 26 （1*2+2*2+4*5）
2 0 3} * 3 2 = 2 （2*1+0*3+3*0） 19（2*2+0*2+3*5）
0 5 }
第一个的列数必须要等于第二个的行数
#include <stdio.h>
#define M 3
#define N 4
#define K 2
int main()
{
int AMK;
int BKN;
int CMN = {0};
int i, j, k;
printf("给数组A32赋值:\n");
for(i = 0; i < M; i++)
{
for(j = 0; j < K; j++)
{
scanf("%d", &Aij);
}
}
printf("给数组B24赋值:\n");
for(i = 0; i < K; i++)
{
for(j = 0; j < N ; j++)
{
scanf("%d", &Bij);
}
}
//-------矩阵乘法---------------
for(i = 0; i < M; i++)
{
for(j = 0; j < N; j++)
{
/*
Cij :
i = 0, j = 0 :
Ai0 * B0j +
Ai1 * B1j +
......
AiK-1* BK-1j
*/
Cij = 0;
for(k = 0; k < K; k++)
{
Cij += Aik * Bkj;
}
}
}
for(i = 0; i < M; i++)
{
for(j = 0; j < N; j++)
{
printf("%d ", Cij);
}
printf("\n");
}
}
6.关于数组的类型
关于xxx的类型，给它定性
它是个什么东西。
int a4 //a是一个含有4个int类型元素的数组
typeof(a) =》int 4
float b10 //b是一个含有10个float类型的数组
typeof(b) => float 10
int a34 //a是一个含有3个元素并且每个元素又含有4个int类型元素的数组
typeof(a) ==>int4 3
7.回顾
关于数组定义：
数组元素的类型 数组名元素个数；
二维数组：
可以从矩阵的角度来看：
几行几列
元素的类型 数组名行号列号
二维数组的元素引用：
数组名行下标列下标
二维数组的存储;
连续的存储空间，从低地址到高地址
从第0行开始，按顺序存储每一个元素。
二维数组的初始化：
只能省略行号不能省略列号
将一个整数m，插入到一个升序的数组（一维数组）中去，使得插入后，数组a仍然有序。
把一个m，插入到有序数组中去，使得插入后仍然有序
（1）找到插入的位置
a,遍历数组
从头开始，一个一个去找，找到数组中第一个比m大的那一个元素，那么，那个元素的
位置，就是我要插入m的位置
for(i=0;i<N;i++)
{
if(ai>m)
{
//找到了
//待插入的位置，下标为i
break；
}
}
b,折半查找法
通过分析:
当循环结束后，那么得到待插入的位置pos
if(amid > m) //往中间插入，或往数组最前面插入一个元素
{
pos = mid ;
}
else if(amid == m)
{
pos = mid; //找到了元素的值为m，那么这个元素的位置就是m要插入的位置
}
else //amid < m 往数组最后面去插入一个元素
{
pos = mid+1;
}
（2）插入操作
假设待插入元素的位置是 pos
将pos及其以后的元素，统统往后移(给待插入元素腾出位置)
再将m赋值给 apos
int L, R, mid, pos; //L 记录数组左边的下标
//R 记录数组右边的下标
//mid 记录 L,R的中间的下标
//pos 记录待插入的位置的下标
L = 0;
R = n-1;
while(L <= R)
{
mid = (L + R)/2;
if(amid > m)
{
R = mid - 1;
}
else if(amid < m)
{
L = mid + 1;
}
else //amid == m
{
//pos = mid;
break;
}
}
if( amid == m )
{
pos = mid;
}
else if(amid > m)
{
pos = mid;
}
else //amid < m
{
pos = mid+1;
}
//(2) 插入m
for(i = N-2; i >= pos; i--)
{
ai+1 = ai;
}
apos = m;
}
练习
1.求一个二维数组中山顶元素的个数
山顶：此处比周围（上下左右）高，就是山顶。
思路：
遍历整个数组，如果此元素比周围的元素值都要大
此处就是一个山顶，count++
int aMN;
int count = 0;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
if(aij比上下左右的元素值要大)
{
count++；
}
}
}
aij比上下左右的元素值要大
它比上面大&&比下面大&&比左边大&&比右边大
它比上面大：
上面不存在元素 || 真比上面大
(i==0) || aij>ai-1j
它比下面大：
下面不存在元素 ||真比下面大
(i == M-1) || aij>ai+1j
....
2.求一个二维数组中的鞍点
鞍点：行最大，列最小
思路;
遍历二维数组，看数组是不是一个鞍点
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
if(aij是鞍点)
{
printf("a%d%d==%d\n",i,j,aij);
}
}
}
aij是鞍点
aij 是第i行最大值 &&是第j列的最小值
定义两个辅助数组：
int bM;//保存每一行的最大值
int cN；//保存每一列的最小值
aij 是第i行的最大值 ==>aij == bi
&& aij 是第j列的最小值 ==>aij == cj
b0 = a00
for(j = 0;j<N;j++)
{
if(a0j>b0)
{
b0 = a0j;
}
}
....
for(i=0;i<M;i++)
{
bi = ai0;
for(j = 0;j<N;j++)
{
if(aij>bi)
{
bi = aij;
}
}
}
cN....
cj = aij
if(aij==bi && aij==cj)
3.最长上升子序列的长度（选做）
1 4 -3 -9 5 9 0
思路：
int aN;
定义辅助数组LN
Li表示以ai结尾的最长上升子序列的长度
4,以下叙述中错误的是？（C）
A,对于double类型数组，不可以直接用数组名对数组进行整体输入或输出
B,数组名代表的是数组所占存储区的首地址，其值不可改变
C,当程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出"下标越界"的出错信息
D,可以通过赋初值的办法确定数组元素的个数
5,以下程序的输出结果是？(45)
main()
{
int p8={11,12,13,14,15,16,17,18};
int i=0,j=0;
while(i++<7) if(pi%2) j+=pi;
printf("%d\n",j));
}
6,有以下程序，程序输出的结果是？(25)
main()
{
int i,s=0,t\[\]={1,2,3,4,5,6,7,8,9};
for(i=0;i<9;i+=2) s+=*(t+i);
printf("%d\n",s);
}
7,有以下程序，如果运行时输入:2 4 6 <回车>，则输出结果为？ (2,0,4)
main()
{
int x32={0},i;
for(i=0;i<3;i++) scanf("%d",xi);
printf("%3d%3d%3d",x00,x01,x10);
}
8,有以下程序，以下叙述中正确的是(B)
#include <string.h> main()
{
char p\[\]={'a','b','c'},q10={'a','b','c'};
printf("%d %d\n",strlen(p),strlen(q));
}
A,在给p，q数组置初值时，系统会自动添加字符串结束符，故输出的长度为3
B,由于p数组中没有字符串结束符，长度不能确定，但q数组中字符串长度为3
C,由于q数组中没有字符串结束符，长度不能确定，但p数组中字符串长度为3
D,由于p,q数组中都没有字符串结束符，故长度不能确定
9,以下能正确定义一维数组的一项是？(B)
A, int a5={0,1,2,3,4,5};
B,char a\[\]={0,1,2,3,4,5};
C,char a={'A','B','C'};
D,int a5="0123"
10,设有如下定义，则正确的叙述为(C)
char x\[\]={"abcdefg"};
char y\[\]={'a','b','c','d','e','f','g'};
A,数组x和数组y等价
B,数组x和数组y长度相同
C,数组x的长度大于数组y的长度
D,数组x的长度小于数组y的长度