1、一维数组
数组是构造数据类型之一，可以类比成一排编号的格子：
每个格子只能存同一种类型的数据（比如全是 int、全是 char）；
每个格子有唯一的下标（索引），从 0 开始（第一个格子是 0 号，第二个是 1 号…）；
所有格子在内存中是连续存储的，访问速度快。
数组可以是一维的，也可以是多维的
所谓一维数组是指只有一个下标的数组，一般形式：<存储类型><数据类型><数组名>[<表达式>];
int a[6]:
数组名标识内存的首地址，是地址常量。sizeof(数组名)是数组占用的总内存空间，编译时分配连续的内存，内存字节数=数组维数*sizeof(元素数据类型)
#include<stdio.h>
int main()
{
int a[6],i;
for(i=0;i<6;i++)
{
printf("%p \\n",a+i);
}
return 0;
}
一个int类型占用4个字节，就可以看得出来，存储地址是连续的，地址是十六进制来标识的
#include<stdio.h>
int main()
{
int a[6],i;
for(i=0;i<6;i++)
{
printf("%p \\n",a+i);
}
printf("%d \\n",sizeof(a));
return 0;
}
共占用了24字节
C语言对数组不做越界检查，使用时要注意
一维数组的引用
数组必须先定义再引用
只能逐个引用数组元素，不能一次引用整个数组
数组元素表示形式：数组名[下标]
其中，下标可以是常量或者整形表达式 例如：
int a[10];
printf("%d",a); //错误写法
for(i=0;i<10;i++)
printf("%d",a[i]); //正确写法
一维数组的初始化
1. 初始化方式：在定义数组的时候，为数组元素赋初值
c int a[5] = {1,2,3,4,5};
#include<stdio.h>
int main()
{
int a[6],i;
for(i=0;i<6;i++)
{
printf("%d \\n",a[i]);
}
return 0;
}
不赋初值，输出为随机数
#include<stdio.h>
int main()
{
int a[6]={1,2,3,4,5,6},i;
for(i=0;i<6;i++)
{
printf("%d \\n",a[i]);
}
return 0;
}
赋初值之后，输出为初值
2. 说明：
1. 数组不初始化，其元素值为随机数
2. 对static数组元素不赋初值，系统会自动赋以0
3. 只给部分数组元素赋初值
static int a[5];等价于a[0]=0;a[1]=0;a[2]=0;a[3]=0;a[4]=0;
int a[5] = {6,2,3}; 等价于: a[0]=6;a[1]=2;a[2]=3;a[3]=0;a[4]=0;
int a[] = {1,2,3,4,5,6}; 编译系统根据初值个数确定数组维数
#include<stdio.h>
int main()
{
int a[]={1,2,3,4,5,6},i,n;
n = sizeof(a)/sizeof(int);
for(i=0;i<n;i++)
{
printf("%d \\n",a[i]);
}
return 0;
}
冒泡排序
#include<stdio.h>
int main()
{
int a[]={1,13,6,4,8,12},i,j,n;
int t = 0;
n=sizeof(a)/sizeof(int);
for(i=0;i<n;i++)
{
printf("%d ",a[i]);
}
printf("\\n");
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1-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]);
}
printf("\\n");
return 0;
}
核心思想
遍历数组，相邻两个元素两两比较；
如果前一个元素比后一个小，就交换位置；
每一轮遍历后，最小的元素会 “沉” 到数组末尾；
重复上述过程，直到所有元素有序（每轮遍历的次数逐渐减少）。
初始数组：[1, 13, 6, 4, 8, 12]
第1轮遍历（比较5次）：
1和13交换 → [13, 1, 6, 4, 8, 12]
1和 6交换 → [13, 6, 1, 4, 8, 12]
1和 4交换 → [13, 6, 4, 1, 8, 12]
1和 8交换 → [13, 6, 4, 8, 1, 12]
1和12交换 → [13, 6, 4, 8, 12, 1]
结果：最小的1沉到末尾，后续无需再比较1
第2轮遍历（比较4次）：
13和6不换 → [13, 6, 4, 8, 12, 1]
6和 4不换 → [13, 6, 4, 8, 12, 1]
4和 8交换 → [13, 6, 8, 4, 12, 1]
4和12交换 → [13, 6, 8, 12, 4, 1]
结果：次小的4沉到倒数第二位
… 依次类推，直到所有元素有序
最终数组：[13, 12, 8, 6, 4, 1]
2、二维数组
定义方式：（声明时，列数不能省略，行数可以）
数据类型 数组名[常量表达式][常量表达式]；
int a[3][4]，float a[2][8]
元素个数=行数*列数
存放顺序：内存是一维的，按行序优先
引用
形式：数组名[下标][下标]
二位数组元素的初始化：1、分行初始化，2、按元素顺序初始化
例如： int a[2][3]= {{1,2,3},{4,5,6}};
a[0][0]、a[0][1]、a[0][2]、 a[1][0]、a[1][1]、a[1][2]
#include<stdio.h>
int main()
{
int a[2][3];
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("%p ",&a[i][j]);
}
printf("\\n");
}
printf("%p %d \\n",a,sizeof(a));
printf("%p %d \\n",a[0],sizeof(a[0]));
printf("%p %d \\n",a[1],sizeof(a[1]));
return 0;
}
可以看出，即使是二维数组，但存放地址是连续的
#include<stdio.h>
int main()
{
int a[][3]={{1,2,3},{4,5,6}};
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("%d ",a[i][j]);
}
printf("\\n");
}
printf("%p %d \\n",a,sizeof(a));
printf("%p %d \\n",a[0],sizeof(a[0]));
printf("%p %d \\n",a[1],sizeof(a[1]));
return 0;
}
删去行数不影响结果，删去列数，直接报错
#include<stdio.h>
int main()
{
int a[][3]={{1,2},{4}};
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
printf("%d ",a[i][j]);
}
printf("\\n");
}
printf("%p %d \\n",a,sizeof(a));
printf("%p %d \\n",a[0],sizeof(a[0]));
printf("%p %d \\n",a[1],sizeof(a[1]));
return 0;
}
不够的会自动补0
