标签：
构造类型数据是有基本类型数据按照一定规则组成的。数组，结构体，共用体都属于构造类型的数据。数组是有序数据的集合，C语言数组中的每一个元素都属于同一个数据类型，用数组名和下标来唯一确定数组中的元素。
使用场景：当我们需要存储大量同类型数据的时候可以用数组
一维数组定义：具有相同数据类型变量的有序集合 (空间有序)
声明数组的格式： 类型 数组名[常量表达式]
例： int scores[5] ;
表示：定义了一个整型一维数组，数组名为scores，scores数组有5个元素
说明：
1. 数组名的命名规则？ 遵循标识符命名规则
2. 数组名是？ socres
3. 数组的元素类型是？ int , 去除数组中的scores[]剩下的就是数组元素的类型
4. 数组的类型是？ int [] , 去除数组名剩下的就是数组的类型
5. 数组的元素个数？ 5
6. 数组的元素分别是？ scores[0]、scores[1]、scores[2]、scores[3]、scores[4]
7. 数组的访问格式？数组名[索引/下标] 索引范围 <0 -- (元素个数-1)> 从零开始代表第一个元素 依次类推
一维数组初始化：
1. 上面数组没有初始值，默认是随机值。
2. 使用数组的时候一般要进行初始化，如果不知道数组中要放什么，那么一般做清零处理。int scores[5] = {} ;
3. 数组也可以部分初始化。int scores[5] = {1，2，3} ; 那么数组中的前三个元素是1，2，3 后两个元素默认为0
4. 一般定义的时候要给出元素个数，也可以 int scores[] = {1，2，3，4，5} ; 数据的个数确定就不用指定元素个数
数组越界：数组访问一定不要越界，越界后后果是不可预测的，是危险的，不安全的
其他数组：上面演示的是整型数组，也可以是 char c[5] = {"h"，"e"，"l"，"l"，"o"} ; double , float 等
二维数组定义的格式： 类型 数组名[常量表达式][常量表达式]
二维数组的本质：二维数组可以看成是特殊的以为数组，它的元素又是一个一维数组
例： int scores[2][3] ;
表示：定义了一个整型二维数组，数组名为scores，scores数组有2个元素
说明：
1. 数组的元素个数？ 2 , 紧挨着数组名后的[]中的数字就是数组元素个数
2. 数组的元素类型是？ int [], 去除数组中的scores[]剩下的就是数组元素的类型
3. 数组的类型是？ int [][] , 去除数组名剩下的就是数组的类型
4. 数组的元素分别是？ scores[0][0]、scores[0][1]、scores[0][2]、scores[1][0]、scores[1][1]、scores[1][2]
5. 数组的访问格式？数组名[索引/下标][索引/下标]
6. 一维数组的所有性质，二维数组都满足
一维数组初始化：
1. 上面数组没有初始值，默认是随机值。
2. 使用数组的时候一般要进行初始化，如果不知道数组中要放什么，那么一般做清零处理。int scores[2][3] = {{0，0，0}，{0，0，0}} ;
3. 数组正常初始化。int scores[2][3] = {{1，2，3}，{4，5，6}} ;
4. 二维数组的元素个数初始化的时候可以省去 但是第二个[]中不能省去
数组元素的遍历：一般要用循环对数组进行遍历
//for循环
int a[5] = {1,2,3,4,5};
for (int i = 0; i < 5; i++) {
printf("%d\n",a[i]);
}
//while循环
int a[5] = {1,2,3,4,5};
int i = 0;
while (i<5) {
printf("%d\n",a[i]);
i++;
}
1. 选择排序法
int a[5] = {5，4，3，2，1};
//按照 从小到大排序
选择法:从第一个元素开始 依次拿数组中的每个元素a[i],跟它后面的每个元素进行比较 a[i] 和 a[j]，把大的放后面（if a[i] > a[j] —>a[i]和a[j]交换）
5 4 3 2 1
第一轮:始终拿a[0]跟后面的a[1]a[2]。。a[j]进行比较 ,把大的放后面(if a[0] > a[j]—>交换)
1 5 4 3 2
第二轮:始终拿a[1]跟后面的a[2]a[3]。。a[j]进行比较 ,把大的放后面(if a[1] > a[j]—>交换)
1 2 5 4 3
第三轮:始终拿a[2]跟后面的a[3]。。a[j]进行比较 ,把大的放后面(if a[2] > a[j]—>交换)
1 2 3 5 4
第四轮:始终拿a[3]跟后面的a[4]。。a[j]进行比较 ,把大的放后面(if a[3] > a[j]—>交换)
1 2 3 4 5
int a[5] = {5,4,3,2,1};
//外循环 控制轮次
for (int i = 0; i < 5-1; i++) {
//拿a[i]跟后面的每个元素进行比较
//i = 0
//a[0] 跟 a[1]a[2]a[3]a[4]比较
for (int j = i+1; j < 5; j++) {
if (a[i] > a[j]) {//升序 //如果 a[i] > a[j] 降序
//交换位置
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
}
//打印
for (int i = 0; i < 5; i++) {
printf("%d ",a[i]);
}
printf("\n");
2. 冒泡排序法
int a[5] = {5，4，3，2，1};
//升序
//按照 从小到大排序
冒泡法:每一轮都从a[0]开始 依次拿数组中的相邻的两个元素进行比较( a[j] 和 a[j+1])，把大的放后面（if a[j] > a[j+1] —>a[j]和a[j+1]交换）
5 4 3 2 1
第一轮:从a[0]开始比较,相邻的两个元素进行比较(a[0]和a[1],a[1]和a[2],a[2]和a[3],a[3]和a[4],) ,把大的放后面(if a[j] > a[j+1]—>交换)
4 3 2 1 5 —》第一轮得到一个最大的
第二轮:从a[0]开始比较,相邻的两个元素进行比较(a[0]和a[1],a[1]和a[2],a[2]和a[3]) ,把大的放后面(if a[j] > a[j+1]—>交换)
3 2 1 4 5
第三轮:从a[0]开始比较,相邻的两个元素进行比较(a[0]和a[1],a[1]和a[2]) ,把大的放后面(if a[j] > a[j+1]—>交换)
2 1 3 4 5
第四轮:从a[0]开始比较,相邻的两个元素进行比较(a[0]和a[1]) ,把大的放后面(if a[j] > a[j+1]—>交换)
1 2 3 4 5
int a[5] = {5,4,3,2,1};
//外循环 控制轮次
for (int i = 0; i < 5-1; i++) {
//内循环控制比较过程
//比较次数
//i = 0 4 j = 0 1 2 3
//i = 1 3 j = 0 1 2
//i = 2 2 j = 0 1
//i + 比较次数 = 5-1 -> 比较次数(循环次数) = 5-1-i
for (int j = 0; j < 5-1-i; j++) {
if (a[j] > a[j+1]) {//升序 //如果 a[j] < a[j+1] 降序
//交换位置
int tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
}
//打印
for (int i = 0; i < 5; i++) {
printf("%d ",a[i]);
}
printf("\n");
标签：
原文地址：http://www.cnblogs.com/markstray/p/5578049.html
