1，什么是数组？
一组具有相同数据类型的数据的有序集合
“相同数据类型” “有序集合”
一维数组 二维数组 数组不是基本类型 -》属于构造类型 -》需要我们自己定义数组
2，定义一维数组的语法
元素数据类型 数组名[整型常量或者整型常量表达式];//现在很多编译器支持[]写变量
元素数据类型：可以是任意c语言合法类型 数组名： 数组的名字，要符合标识符的规定 [] 里面指定该数组/集合中元素的个数 例如： int a[5]; 定义了一个数组，名字叫做a，有5个元素，所有元素都是int类型，该数组总共占 5*4=20字节内存， -》定义该数组时，操作系统会分配20个字节的空间，并且和a关联起来 double b[6]; 定义了一个数组，名字叫做b，有6个元素，所有元素都是double类型，该数组总共占 6*8=48字节内存， -》定义该数组时，操作系统会分配48个字节的空间，并且和b关联起来
3，一维数组初始化
初始化：不是普通的赋值语句，而是在定义的时候给初始值
数组的初始化用 {}，元素的初始值写在{}内部
3.1 所有元素都初始化
有多少个元素，{}内部就写多少个初始值，以逗号隔开
int a[5] = {4,7,2,4,9};
3.2 部分元素初始化
{}里面的初始值的个数少于数组元素个数
int a[5] = {5,6};
5,6给前两个元素进行初始化，后面的三个元素会采用默认值(int类型的默认值为0,double类型的默认值
为0.0，char类型的默认值为 '\0')
3.3 如果[]内的数字省略，那么数组元素的个数就是{}内部初始值的个数
int a[] = {1,2,3};//数组a有3个元素，分别初始化为1,2,3
4，有序集合的有序怎么理解？
数组的各个元素在内存中的存储是连续并且有序的
int a[5]; //这5个元素在内存中是连续并且有序的
数组中的各个元素怎么表示？
两种方法：下标法和指针法
数组名[下标] -> 下标是一个整数 范围是 [0,n-1] (n是数组元素的个数)
比如：
int a[5];
5个元素分别怎么表示？
a[0] a[1] a[2] a[3] a[4]
没有a[5]这个元素，代码中不能出现这样的情况，否则就是错误的（注意：编译的时候可能检测不到）
数组元素的访问：
和普通变量的访问方式完全一样，分为两种：读访问/写访问
//以普通变量a为例
int a;
a = 10; //写访问
int b;
b = a; //读访问
printf("%d\n",a);//读访问
scanf("%d",&a);//写访问
数组元素的访问
int a[5];
a[0] = 1;//写访问
a[1] = 2;
...
a[4] = 5;
printf("%d\n",a[0]);//读访问
...
printf("%d\n",a[4]);
scanf("%d",&a[0]);//写访问
...
scanf("%d",&a[4]);
练习： 1，定义一个数组，然后依次从键盘输入各个元素的值，最后依次打印输出各个元素的值 2，定义一个数组并初始化，求这个数组所有元素之和 3，定义一个数组并初始化，求这个数组所有元素的最大值和最小值 "擂台法" 假设某个元素(一般是第一个元素)是最大的，然后其它元素一个一个进行笔记，永远保留最大值 全部比完之后，保存的就是最大值
4， 假设一对小兔子的成熟期是一个月，如果每对成熟的小兔子成熟之后的每个月都可以生下一对小兔子， 第一个月有一对小兔子，求前10个月每个月有多少对小兔子
第一个月出生，第二个月成熟，第三个月开始生小兔子 1 1 2 3 5 8 13 .... ->斐波拉契数列 sn = sn-1 + sn-2 n>=3
5，数组排序(以升序进行讲解)
冒泡排序
假设n个元素
总共进行n-1轮比较，每一轮比较都会把未被排序中的最大值放在最后面
int a[5] = {9,7,5,3,1};
int n = 5;//元素个数
int i,j;
int temp;//用来进行交换的临时变量
第1轮排序：
把n个元素中的最大值放在最后面 a[n-1]
怎么实现？
从前往后，两两比较，前面的元素大，就交换他们的值
9,7,5,3,1
7,9,5,3,1
7,5,9,3,1
7,5,3,9,1
7,5,3,1,9
可以看出第一轮要比较 n-1次
for(j=0;j<n-1;j++)
{
if(a[j] > a[j+1])//比较a[j]和a[j+1]
{
//前面的比后面的元素大，进行交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
第2轮排序：
把n-1个元素中(因为上一轮已经排好了一个)的最大值放在最后面 a[n-2]
7,5,3,1,9
5,7,3,1,9
5,3,7,1,9
5,3,1,7,9
可以看出第2轮要比较 n-2次
for(j=0;j<n-2;j++)
{
if(a[j] > a[j+1])//比较a[j]和a[j+1]
{
//前面的比后面的元素大，进行交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
.....
->
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1-i;j++)
{
if(a[j] > a[j+1])//比较a[j]和a[j+1]
{
//前面的比后面的元素大，进行交换
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
选择排序：
进行n-1轮，每一轮都会找出未排序中元素的最大值，然后把它和未排序中的最后一个元素交换
int a[6] = {4,1,8,5,9,6};
第一轮：
找出未排序中最大值9并且记录它的下标 index，和a[n-1]进行交换
temp = a[index];
a[index] = a[n-1];
a[n-1] = temp;
4,1,8,5,6,9
int max_index,temp;
int j;
max_index = 0;//假设下标为0的元素是最大的
for(j=0;j<n;j++)
{
if(a[j]>a[max_index])
{
max_index = j;
}
}
//交换 a[max_index] 和 a[n-1]的值
if(max_index != n-1)
{
temp = a[max_index];
a[max_index] = a[n-1];
a[n-1] = temp;
}
第二轮：
找出未排序中最大值8并且记录它的下标 index，和a[n-2]进行交换
temp = a[index];
a[index] = a[n-1];
a[n-1] = temp;
4,1,6,5,8,9
max_index = 0;//假设下标为0的元素是最大的
for(j=0;j<n-1;j++)//由于第一轮已经把最后一个排好了，所以第二轮不需要考虑它了
{
if(a[j]>a[max_index])
{
max_index = j;
}
}
//交换 a[max_index] 和 a[n-2]的值
if(max_index != n-2)
{
temp = a[max_index];
a[max_index] = a[n-2];
a[n-2] = temp;
}
第三轮：
找出未排序中最大值6并且记录它的下标 index，和a[n-3]进行交换
4,1,5,6,8,9
第四轮：
找出未排序中最大值5并且记录它的下标 index，和a[n-4]进行交换
4,1,5,6,8,9
可以发现，有时候， 要交换的两个元素的下标是相等的(是同一个元素)，不需要交换
-》在交换之前进行判断
第5轮：
找出未排序中最大值4并且记录它的下标 index，和a[n-5]进行交换
1,4,5,6,8,9
->
int i,j,temp;
int max_index;
for(i=0;i<n-1;i++)
{
max_index = 0;//假设下标为0的元素是最大的
for(j=0;j<n-i;j++)
{
if(a[j]>max)
{
max_index = j;
}
}
//交换 a[max_index] 和 a[n-1-i]的值
if(max_index != n-1-i)
{
temp = a[max_index];
a[max_index] = a[n-1-i];
a[n-1-i] = temp;
}
}
换一种写法实现选择排序（升序）：每一轮把最小的元素和前面的元素交换
int i,j;
int temp;
int a[10] = {....};
int n=10;
int min_index;
第一轮：
找出未排序中最小值并且记录它的下标 index，和a[0]进行交换
min_index = 0;
for(j=0;j<n;j++)
{
if(a[j]<a[min_index])
{
min_index = j;
}
}
//交换 a[min_index] 和 a[0]
if(min_index != 0)
{
temp = a[0];
a[0] = a[min_index];
a[min_index] = temp;
}
第二轮：
找出未排序中最小值并且记录它的下标 index，和a[1]进行交换
min_index = 1;
for(j=1;j<n;j++)
{
if(a[j]<a[min_index])
{
min_index = j;
}
}
//交换 a[min_index] 和 a[1]
if(min_index != 0)
{
temp = a[1];
a[1] = a[min_index];
a[min_index] = temp;
}
第三轮：
找出未排序中最小值并且记录它的下标 index，和a[2]进行交换
min_index = 2;
for(j=2;j<n;j++)
{
if(a[j]<a[min_index])
{
min_index = j;
}
}
//交换 a[min_index] 和 a[2]
if(min_index != 0)
{
temp = a[2];
a[2] = a[min_index];
a[min_index] = temp;
}
.....
第n-1轮(最后一轮)：
找出未排序中最小值并且记录它的下标 index，和a[n-2]进行交换
找到规律：每一轮都是类似的代码
->
for(i=0;i<n-1;i++)
{
min_index = i;
for(j=i;j<n;j++)
{
if(a[j]<a[min_index])
{
min_index = j;
}
}
//交换 a[min_index] 和 a[i]
if(min_index != 0)
{
temp = a[i];
a[i] = a[min_index];
a[min_index] = temp;
}
}
6,一维字符数组
数组元素类型为char
前面讲的所有关于一维数组的语法都适用于一维字符数组
如：
char c[5] = {'a','b','c','d','e'};
char c[5] = {'x','y'};//后面三个元素默认为字符 '\0'
char c[] = {'x','y','z'};//3个元素
下标法访问数组元素
printf("%c\n",c[0]);
printf("%c\n",c[1]);
...
printf("%c\n",c[n-1]);
c[0] = 'X';
...
c[n-1] = 'Y';
scanf("%c",&a[0]);
...
scanf("%c",&a[n-1]);
但是字符数组和其它类型的数组有一些独有的语法：
1,初始化可以用双引号
char c[5] = {'x','y','z'};
char c[5] = "xyz";
两种写法效果一样，都是前三个元素为 'x','y','z'，后面两个为 '\0'
char c[] = {'x','y','z'};//只有3个元素
char c[] = "xyz";//有4个元素，除了 'x','y','z'，还有一个'\0'
//所有用 "" 引起来的字符串都包含一个 '\0'
2,用 printf打印数组元素的时候，可以用 %s一次性打印
char c[5] = {'x','y','z'};
int i;
for(i=0;i<5;i++)
{
printf("%c",c[i]);
}
printf("%s\n",c);//等价 printf("%s\n",&c[0]);
这个打印的底层的具体实现过程：
从数组的第一个元素开始逐个字符打印，直到遇到'\0'('\0'被称之为字符串结束标志)
也就是说，使用%s打印字符串/字符数组时，必须保证该数组中有一个 '\0'，否则可能发生错误(内存越界)
3,用 scanf输入数组元素的时候，可以用 %s一次性输入
char c[6];
int i;
for(i=0;i<6;i++)
{
scanf("%c",&c[i]);
}
-------
scanf("%s",c);//从键盘获取一串字符保存在数组中，并且最后自动添加一个'\0'(前提是空间足够)
作业：
1，逆置数组的所有元素
1 2 3 4 5
以中间元素为轴，对称交换，交换n/2次就行
int a[10] = {......};
int n = 10;
int i;
for(i=0;i<n/2;i++)
{
//交换 a[i] 和 a[n-1-i]
temp = a[i];
a[i] = a[n-1-i];
a[n-1-i] = temp;
}
2，三个数组（元素都是int类型）
数组a有5个元素，并且是从小到大排序好了的
数组b有8个元素，并且是从小到大排序好了的
现在合并这两个数组，保存到数组c中（合并的过程中要保持数组c有序）
1 4 7 9 10
-1 0 7 12 90 100 102 120
-1 0 1 4 7 7 10 12 90 100 102 120
3，完成插入排序
把这个数组分为两部分，左边部分是排序好的，右边部分是未排序的
14 10 -23 25 234 100 1
初始时：左边部分(排好序的)只有一个元素，开始进行排序，需要进行 n-1轮插入
每一轮都会把右边的(未排序部分)第一个元素插入到左边，并使之有序
每次插入的时候，都会从右到左依次拿左边排好序的数据和当前要插入的数据x作比较
如果比x大，则往右挪动一个位置，比x小则不需要挪动(x就插入到这个元素的后面)
1: 10 14 -23 25 234 100 1
2: -23 10 14 25 234 100 1
3: -23 10 14 25 234 100 1
4: -23 10 14 25 234 100 1
5: -23 10 14 25 100 234 1
6: -23 1 10 14 25 100 234
--------------------------------------------------------
初始时：左边部分(排好序的)只有一个元素，开始进行排序，需要进行 n-1轮插入
每一轮都会把右边的(未排序部分)第一个元素x插入到左边，并使之有序
每次插入的时候，从右到左找到左边以排好序的数据中的第一个比 x小的元素y
找到了的话，就把这个元素后面的所有元素往后挪动一个位置，并且把x放在y的后面
进阶：二分插入排序
4，在一个有序的数组中查找是否存在某个元素，如果存在打印它的下标，不存在打印-1
用两种方法实现
5，求最大连续子数组之和
如：
数组 a 7 4 -1 10 -6 9
连续子数组
7
7 4
7 4 -1
7 4 -1 10
7 4 -1 10 -6
7 4 -1 10 -6 9
4
4 -1
4 -1 10
4 -1 10 -6
4 -1 10 -6 9
.....
二维数组
1，二维数组的定义语法
数据类型 数组名行大小;
如：
int a3 ; -> 类比数学上的矩阵，3行4列
共3*4=12个元素，每个元素都是 int 类型
2，二维数组在内存中的存放顺序
连续的按顺序存储
数组中的各个元素怎么表示？
下标法 ：
数组名行下标;
行下标的范围 : [0,行大小-1]
列下标的范围 : [0,列大小-1]
千万不要越界
如：
int a3; 总共12个元素，按顺序分别是：
3，二维数组的初始化
也是用 {} 具体有几种情况 (1) 给全部元素赋值 int a2 = {1,2,3,4,5,6};
(2) 给部分元素赋值
int a[2][3] = {1,2,3}; //1->a[0][0] 2->a[0][1] 3->a[0][2]
//剩下三个元素都是默认值 0
(3) 给每一行的全部元素赋值
int a[2][3] = {{1,2,3},{4,5,6}};
(4) 给某一行的部分元素赋值
int a[2][3] = {{1,2},{4}};//1->a[0][0] 2->a[0][1] 4->a[1][0]
//剩下三个元素都是默认值 0
(5)可以省略行大小（列大小不能省略）
会根据{}里面的初始值的个数和列大小计算行大小
int a[][3] = {1,2,3,4,5,6}; //行大小为2
int a[][3] = {1,2,3,4,5,6,7};//行大小为3，并且最后两个元素都是默认值 0
练习： 1，定义一个二维数组，然后依次从键盘输入各个元素的值，最后依次打印输出各个元素的值 2，定义一个二维数组，并初始化，然后求所有元素中的最大值和最小值 3，打印杨辉三角的前10行 1 0 0 0 0 0 1 1 0 0 0 0 1 2 1 0 0 0 1 3 3 1 0 0 1 4 6 4 1 0 1 5 10 10 5 1 ............ 4，求一个二维数组“山顶元素”的个数 “山顶元素” ：比周围(上下左右)的都大 注意：不要下标越界 四个条件同时成立： 当前元素 a[i][j] 1,上面不存在元素 或者 如果上面存在元素并且比上面的元素大 i==0 || (i>0 && a[i][j]>a[i-1][j]) 简化 i==0 || a[i][j]>a[i-1][j] 不等价 a[i][j]>a[i-1][j] || i==0 (错误) 2，下面不存在元素 或者 如果下面存在元素并且比下面的元素大 i==行大小-1 || a[i][j]>a[i+1][j] 3， .... 4， .....
作业：
1，上台阶问题
2，定义一个字符数组，求这个字符串的长度
字符串的长度：从第一个字符开始，到'\0'为止(不包括'\0')，总共有多少个字符
char a[] = {'1', '2', '\0'};//这个字符串的长度为2
//数组的长度(数组元素个数) 为 3
char a[10] = {'1','2','\0','3','4'};
int i;
int len = 0;
for(i=0;i<10;i++)
{
if(a[i]!='\0')
{
len++
}
else
{
break;
}
}
3，占座位问题
1181
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
