C 碎片五 数组

构造类型数据是有基本类型数据按照一定规则组成的。数组，结构体，共用体都属于构造类型的数据。数组是有序数据的集合，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. 二维数组的元素个数初始化的时候可以省去 但是第二个[]中不能省去

三、字符和数组

区分四个零0，‘0’，‘\0’，“0” （字符‘\0’也即为空和数字0的ASCII码值是一样的）“0”包含一个字符0和‘\0’

各种数组初始化为空的方法：

对比下面的结果得出：初始化为空(0)时，就是在内存中让这段地址的ASCII码值为0

所以{}，0，/0，其实效果是一样的，为了不引起歧义，int型对应{}或0，char型

对应{}或/0，另外的也可以，但不推荐。

//++++++++++++++++++++++++++++++++++++++++//

1.整型数组(float,double)： int a[10]={}; int a[10]={0}; int a[10]={‘\0’}

2.字符型数组：一维: char a[10]={}; char a[10]={0}; char a[10]={‘\0’};

二维: char a[10][10]={}; char a[10][10]={0}; chara[10][10]={‘’0’};

下面需要重点说明，指针数组里面存放的是地址（长整形8个字节），所以初始化为空的时候打印的都是0

3.指针数组：int型 int * p[10]={}; int * p[10]={0}; int * p[10]={‘\0’};

char型 char * p[10]={}; char * p[10]={0}; char * p[10]={‘\0’};

四、循环和数组

数组元素的遍历：一般要用循环对数组进行遍历

    //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");