大纲:

    1.什么是数组
    2.怎么定义数组
    3.数组的初始化
    4.数组的引用  + 遍历
    5.数组的长度(元素个数)
    6.数组的内存分析
    7.数组找最大值  +  排序




int arr[3] = {1,2,3};

arr[0]  --->  1


//错误
arr[3]  --->  越界了


for(int i = 0;i<3;i++){
   
   
    printf("%d",arr[i]);   // 直接获取值
   
                            //间接的获取值  指针跟数组的关系 你ok了
   
}







//------------------数组的基本概念及分类
# 是什么:
用来存储一组数据的容器.

详细分析:

把具有
相同类型
的若干变量
按
有序
的形式组织起来。这些按序排列的
同类数据元素
的集合称为
数组


float arr[3];  ---->
1.这是个数组  2.这个数组里面的元素必须是float类型  3.里面只能存放3个元素



## 构造类型:
在C语言中,数组属于构造数据类型。
一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。

//-----------------------  一维数组 --> 简称 --> 数组
什么叫一维数组: 这个数组里面存放的不是数组,我们就称这个数组为一维数组

int arr[5] = {1,2,3,4};

int arr[3];   //一维数组

这个数组里面可以存放3个(int)元素,这个三个都必须是int类型的元素

int arr[数组的长度--->数组元素的个数];

//-------------------数组的定义

格式:
类型说明符 数组名[数组长度];

char arr[10];
------>   是什么: 数组   数组名: arr  数组的元素个数 :  10   元素类型 : char

注意点
1) "数组的类型实际上是指数组元素的取值类型"。对于同一个数组,其所有元素的数据类型都是相
同的。第一个数组元素的地址是数组所占内存块的首地址

int arr[5];  //  定义了一个数组   这个数元素个数是  5  从arr[0]....arr[4]

//数组的赋值
arr[0] = 1;
arr[1] = 2;
.....


2) 数组名的书写规则应符合标识符的书写规定。 命名规则:
/*
1、只能由字母、数字、下划线组成
2、不能数字开头
3、不能与关键字重名
4、严格区分大小写

命名规范:
1、起一个有意义名字
2、驼峰标示
*/

3) 数组名不能与其它变量名相同。



4) 方括号中常量表达式表示数组元素的个数,如int a[5]表示数组a有5个元素。但是其下标从0开始计算。a[0]  a[1] ....  a[4]


int arr[10];
arr[0]  --->   "数组的下标"
arr[1]
arr[2]
arr[3]
arr[4]

"我定义长度为5   数组的下标   0----n-1"


5) xcode的编译器特性

c99   不允许变量作为数组的长度  ,  在xocde下可以

int num = 10;
int arr[num];   //  注意!

1.  正确:
int num  = 10;

int arr[num];
----------------

2.错误的:
int num = 10;

int arr[num] = {1,2,3,4,5,6,7,8,9,10};  //错误的


"总结一句话: 定义数组必须要确定长度"

int arr[] = {1,2,3};   //  数组元素的个数  3  arr[0]  arr[1]  arr[2]


//---------------------数组的初始化
1."定义的同时,直接初始化:"
类型说明符 数组名[常量表达式] = { 值, 值......值 };

int arr[5] = {1,2,3,4,5};   //  直接初始化

其中在{ }中的各数据值即为各元素的值,各值之间用逗号间隔。


2."先定义后初始化(赋值):"
类型说明符 数组名[常量表达式];

int arr[5];   //定义

arr[0] = 1;   //赋值
arr[2] = 2;
.....
arr[4] = 5;   //  初始化


思考: 未初始化的数组元素的值是多少呢?

垃圾数



//--------------------数组的引用  数组名[下标]
数组元素通常也称为下标变量。必须先定义数组,才能使用下标变量。


int arr[10] = {1,2,3,4,5,6,7,8,9,10};

数组元素通常也称为下标变量。必须先定义数组,才能使用下标变量。

正序输出
for (int i=0; i<10; i++) {
    printf("%d\t",a[i]); }

逆序输出
for (int j=9; j>=0; j--) {
    printf("%d\t",a[j]); }

越界总结:
一个长度为n的数组,最大下标为n-1, 下标范围:0~n-1
1、如果越界了就相当于(访问自己不该访问存储空间)


//-----------------------数组的注意事项

1. 定义数组必须确定的长度
int arr[];   //错误的
int arr[5];  //正确        数组长度为5
int arr[] = {1,2,3,4,5}; //正确   数组长度为5
结论:"定义数组一定会确定数组长度"


2.使用整型变量作为数组长度
int count = 5;
int arr[count] = {1,2,3,4,5};   //错误的

int arr[count];  //正确的
arr[0] = 1;
arr[1] = 1;
...
结论:"使用变量作为数组长度表示,只能定义数组,不能立马对数组进行初始化"


3.关于数组初始化注意事项
1.完全初始化
int nums[5] = {1,2,3,4,5};

2.局部初始化
int arr[100] = {1,2};      //系统会自动将其初始化为0

arr[0] = 1
arr[1] = 2
arr[2] = 0
arr[3] = 0

3.个别初始化




4.数组越界问题
int arr[n];  下标:   0 ---  n-1

arr[3] = 5;  //错误   越界   数组下标使用从0开始

以下正确
arr[0] = 5;
arr[1] = 2;
arr[2] = 3;

结论:数组下标从0开始算,最大下标为(数组元素个数-1)


//---------------------数组的存储方式

数组首地址概念   ---->   arr(数组名)  代表的就是数组首地址

int arr[3] = {1,2,3};



//----------------------------  数组长度 ---->  数组元素的个数
数组长度  =  sizeof(数组名) / sizeof(类型)

sizeof(数组名) ------> 整个数组占的总字节数

sizeof(类型)  ----->  整个数组中一个元素占的字节数


数组的长度 = 数组占用的总字节数 / 数组元素占用的字节数


结论:
你要计算这个数组的长度,你必须在作为参数传递之前计算这个数组的长度   长度作为参数传过去用

int a = 999;

sizeof(&a)   --->   8


int arr[5] = {1,2,3,4,5};    //  5

int arr[] = {1,2,3,4,5};    //  5

int arr[] = {1,2,3,4,5.....};   //   sizeof(数组名)/sizeof(类型)  --->  数组的元素个数(长度)

//-----------------------数组作为函数参数

数组用作函数参数有两种形式:

一种是把数组元素(下标变量)作为实参使用;

一种是把数组名作为函数的形参和实参


-------------------------------------------------------------------

数组元素   作函数实参,就是把    数组元素的值    传送给形参      //值传递

数组名     作为函数参数       是把数组的地址    传递给形参数    //地址传递

-------------------------------------------------------------------


注意:用数组名作函数参数时,则要求形参和相对应的实参都必须是类型相同的数组


注意点
1形参数组和实参数组的类型必须一致,否则将引起错误。

2形参数组和实参数组的长度可以不相同 (但是容易出现问题) // 不要这么写

3在函数形参表中,允许不给出形参数组的长度,或用一个变量来表示数组元素的个数。


//------------------冒泡排序

大数下沉
1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应 该会是最大的数。
3)针对所有的元素重复以上的步骤,除了最后一个。
4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。


for (int i=0; i<len-1; i++){
    //每趟排序都会确定一个数,所以需要再循环len-i次,但因为每次都是 //相邻的两个数进行比较,为了a[j+1]不越界,让j循环到len-i-1时停止。
    for (int j=0; j<len-i-1; j++) {
        
        
        if(arr[j]>arr[j+1]){
            
            int temp = arr[j];
            
            arr[j] = arr[j+1];
            
            arr[j+1] = temp;
            
        }
        
    }
   
}


//------------------选择排序思想
外层 len-1   里层  j=i+1  j<len


//每一趟都是拿着一个元素与后面其他元素进行比较,找出最小值 void selectSort(int array[],int len)
{
    // 1、确定需排序趟数
    for (int i = 0 ; i < len - 1; i++) { // 2、每一趟怎么处理
        for (int j = i + 1; j < len; j++) {
            if (array[i] > array[j]) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
}

int arr[] = {..........};

搞嫩长.........