学习日志以及个人总结（第七天）

上接第六天 （break语句和continue语句）的流程图

数组:一组相同类型的数据的集合

顾名思义一次性定义多个变量（一组变量）
//本质上是相同类型变量的集合

不用数组 就一个一个输入 int ....

一维数组
整型  字符型
二维数组
整型  字符型
--------------------------------------------------
语法：
类型说明符   数组名 [常量表达式]；

（1）.类型说明符
        整型 int short long long long
        浮点
        字符
（2）.数组名
        代表着 数据集合 (内存空间的一个名字)
        从数据类型角度来看 
        数组名(a)代表
        
（3）.[] //表示此时定义的是一个数组
（4）.常量表达式
      表示数组的长度 ---变量的个数

例子：
int array[5];//定义一个数组，这个数组放了5个int型变量  这个数组名叫array
int array[40];

数组本身也是一种"数据类型"

"注意 整型 字符型 浮点型 为数据类型的基本类型"

类型：    变量    常量    大小    内存
变量的定义： 数据类型 变量名
            int[10] a; // a所代表的类型是 int[10]

int a = 10;//a是int型
int a[10];//把名字去掉 剩下的就是a对应的数据类型 此处为int[10]的类型

int a[10];//数组再内存空间上的特点

//数组的给值
//初始化
//赋值  数组赋值不能整体赋值
int a[10] ={1,2,3,4,5,6,7,8,9,10};//{}  //表示初始化  --初始化器
                                  //全部初始化
                                  
                                  
//数组元素的访问
语法： a[下标];//0开始的
               //1开始的
    数组下标：本质上是偏移量※

赋值的方式---给数组中输入一些值？

scanf("%d",& a[i]);//

数组的特点：
1.连续性 --一片连续空间
2.有序性 --元素依次存储
3.单一性 --单一元素的元素

a[i] //下标运算---本质 实际是一个地址的运算
下标本质上是一个偏移量 
    a[0] 偏一个0 是本身
    a[1] 偏一个1 是下一位
    
        a[i]<==>i[a]  一样的
        
数组越界问题：
1.不是语法问题 ---编译器不会报错；
                               cautious！！！
a[-1] 向前偏移 

数组总结 ：    数组名代表的类型
            下标的意义 ----偏移量
            1.数组概念：
            数组：一组相同类型数据的集合
            2.语法
            数据类型 数组名[数组长度]；
            3.定义 
            int a[10];
            连续性 有序性 单一性
            4.注意
            a.数组名
            代表的数据类型 --数组类型 int a[10]；//a代表的类型为int[10]
            代表的值 --数组首元素的地址//&a[0]
            b.数组长度与下标
            数组长度--表示几个元素（变量）
            下标---偏移量
                    [0~数组长度-1]
            int a[10]; [0~9]
            5.数组的初始化
            int a[10] ={1,2,3,4,5,6,7,8,9,10};//全部初始化
            int a[10] ={1,2,3,4,5};//部分初始化--一次给到数组元素
                                    //没给值的而元素，默认为0
            将数组初始化为0
            int a[10]={}; //都初始化为0
            int a[10]={0}；//都初始化为0
            数组不初始化----数组为垃圾值
            
            6.数组长度可省略
            有前提--必须要有初始化的值
            int a[]={1，2，3}；//编译器会通过值来计算数组长度
            
            
排序：按一定的顺序排列

    
    升序 1 2 3 4
    降序 4 3 2 1          
------------------
选择排序：
    为合适的位置，选择一个合适的数
01234567//下标
52368714//数值

0号位置：最小值
i=0;
for(j=1;i {
    if(a[j]     {
        交换
    }
}
1号位置 也找最小值
i=0;
for(j=2;i {
    if(a[j]     {
        交换
    }
}

发现是在一个循环里面 
for(i=0;i {
    //找最小值
    //i=1
    for(i=i+1;j     {
        if（a[j]         {
            交换
        }
    }
}

冒泡排序：
思想：
    相邻两个元素两两比较，小的放前，大的放后
    
01234567//下标
15368724//数值
第一趟 
n=8 比较7次 冒一个数
第二趟
n=7 比较6次 冒一个数
...
第7趟
n=2 比较次数1 冒一个数

第n-1躺 
n

for(j=1;j {
for(int i = 0;i {
    if(a[i]>a[i+1])
    {
        交换
    }
}

}