一  数组的基本概念


1、什么是数组？

    一组 相同类型 的 若干 个 有序 的数据集合

2、数组的名词：

    1）数组名:带表一组相同类型若干个有序的数据集合（）
    2) 数组元素：构成数组的每一个元素
    3）下标：数组是有序的，下标有序，用来标识每个元素在数组中的位置
    4）数组的维度： 元素下标的个数
    5）数组的长度：集合中元素的个数

3、分类：
   
    1）按内容分类：数值型数组（整型、实型）、字符型数组、指针数组、构造数组

二  一维数组


   1、什么是一维数组？

       每一个元素都是基本类型（int float char）的数据

       数组的使用流程：先定义--->初始化--->引用（使用）

   2、一维数组的定义？

       格式：

           数据类型   数组名[长度];

                          1+2  4+5
           int a[10];
           定义了一个整型的数组a
           另一种描述：定义了了一个长度为10，每个元素都只能存放int型数据的数组  数组名是a

           int 表示数组中每个元素的类型都必须是int型

       注意:

          1）a是数组的名称，a需要遵守标示符的命名规范
             （1）字母、数字、_ 、美元符号组成，不能以数字开头，不能和关键字重名，严格区分大小写

          2）数组长度不能使用变量，
  
             int n=5;  int arr[n]; 这种写法C规范不可以，但是Xcode可以

          3）数组长度可以使用宏定义
   
             #define N 5; int arr2[N+3];这种写法是可以的

         
          4）数组名不能和其他变量重名

             int a;
             int a[10];错误的

          5）可以一次定义多个数组

             int a[10],b1[3]; 表示定义了两个整型数组，第一个数组名a,能存放10个int型的数据，第二个数组 b1 能存放3个int型数据

          6）数组定义后，只能存放定义类型的数据
            int a[10]; 只能存放int型数据

          7）可以定义变量的同时，定义数组
            
             int a,b,arr[10];
三 数组的初始化
1、数组的初始化

变量的初始化， 给变量赋初值
数组的初始化，给数组中的每个元素都要进行初始化；

2、数组的初始化的方法

     数组如果定义完成以后，没有进行初始化，这个时候，元素的值是随机数（垃圾值）

     初始化的格式：int 数组名[长度]={值1,值2,.....}

    1）定义的同时进行初始化     int a=10;

       （1)完全初始化

            int a[5]={1,2,3,4,55};
            注意：初始化数值得个数可以小于长度，但是不能大于长度

            不指定数组长度的完全初始化
            int a3[]={1,2,3}; //定义一个数组，数组的长度由初始化的元素的个数决定的

            误区：
                a3={1,2,3};   错误
                a3[]={1,3,4}; 错误

        (2)部分初始化

            int a1[5]={1};   //优先把1初始化给第一个元素

           指定元素的部分初始化

            int a2[5]={[2]=1,[4]=100};
            // 给第三个元素初始化为1  给第5个元素初始化为100
  


    2）先定义，后初始化

       误区：
         int a1[5];
         a1[]={1,2,3}; 错误的
         a1={1,2,3};   错误的


       正确用法：每个元素逐个进行初始化

         a1[0] = 10;
         a1[1] = 100;
         a1[2] = 1000;
         a1[3] = 10000;
         a1[4] = 1;

         a1[5] = 0; //错误的


   3、数组的引用

     数组的引用，其实就是获取数组中存储的内容
     可以通过数组下标，来访问数组中的每一个元素
     如果说数组长度为n , 下标的最大值 n-1,最小是 0
     如果说某个数组的下标最大值是n,数组最少有 n+1个元素

     格式: 数组名[下标]

     int a[5]={1,2,3,4,5};
     char c[34] 下标取值范围 0-33;
     数组第一个元素 a[0]    1
                  a[1]    2
          3）数组长度可以使用宏定义
   
             #define N 5; int arr2[N+3];这种写法是可以的

         
          4）数组名不能和其他变量重名

             int a;
             int a[10];错误的

          5）可以一次定义多个数组

             int a[10],b1[3]; 表示定义了两个整型数组，第一个数组名a,能存放10个int型的数据，第二个数组 b1 能存放3个int型数据
  四  数组的练习


#include <stdio.h>

int main()
{
   
   
    //定义一个数组
    int a[50];
    //通过for循环给数组赋值
    for (int i=0; i<50; i++) {
        a[i]=i+1;
    }
   
   
     
     //打印数组的每一个值，遍历
     for (int i=0; i<50; i++) {
         printf("%d\t",a[i]);     }
          return 0;
            }
五  数组的储存方式
#include <stdio.h>
int main()
{
    //1、数组的存储方式
    //每个地址相差4个字节
    int a[3]={13,34,438};
    //数组的首地址 = a[0]的地址 = a
    //所以，数组名存放的实际上是数组的首地址
   
    printf("a = %p \n",a);
    printf("a[0]=%p\n",&a[0]);  //地址最低
    printf("a[1]=%p\n",&a[1]);
    printf("a[2]=%p\n",&a[2]);  //地址最高
   
   
   
    //2、数组的长度计算方法
    // 数组在内存中占用的字节数：sizeof(int)*n个数  = sizeof(数组名)
    printf("数组占用的字节数：%ld\n",sizeof(a));
    //计算数组的元素个数
    printf("数组的个数：%ld\n",sizeof(a)/sizeof(int));
   
    //
    int a1[]={1,2,3,4,4,5,6,6,70,24,5,6,6,89};
    int length = sizeof(a1)/sizeof(int);
    //长度是14 ：0-13
    printf("length:%d\n",length);
    //访问数组的下标，超过了最大下标
    //约错了对象，越界程序会给出警告，但是不会报错，千万要注意越界
    //printf("a[14]=%d\n",a1[14]); //越界
    return 0;
}
练习 2
求数组中的最大值
#include<stdio.h>

void tese2()
{
   
    int a[10];  int max=-1;//默认max是最大值
    for (int i=0;i<10 ; i++)
    {
        printf("请输入一个整数");
        scanf("%d",&a[i]);//接受整数存放数组里面
    }
    for (int j=0; j<10; j++) {
        if (a[j]>max) {
//拿当前的值和前面的笔记如果大于前面的值，就赋值给前面的数

            max=a[j];
        }
        
    }
    printf("最大的数是%d\n",max);
}


int main(){
   
   
   
   
    tese2();
   
   
   
   
   
   
    return 0;
}

3 // 冒泡排序的题目
#include<stdio.h>

void sortArray(int a[],int len)
{
    //定义变量
    int temp;
    //循环控制趟数
    for (int i=0; i<len-1; i++) {
        
        //控制两两比较，比较的次数  0 ~ len-1-i;
        
        for (int j=0; j<len-1-i; j++) {
            // a[j]>a[j+1]  交换
            if (a[j]>a[j+1]) {
                //让a[j]和a[j+1]交换
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}
int main()
{

    int arr[10]={34,66,32,63,76,45,53,32,98,99};
    //打印排序前的
    for (int i=0;i<10;i++) {
        printf("%d\t",arr[i]);
    }

    printf("\n");
    //调用冒泡排序
    sortArray(arr, 10);
    printf("\n");
   
    //打印排序后的
    for (int i=0;i<10;i++) {
        printf("%d\t",arr[i]);
    }
   
    printf("\n");






    return 0;
}
注意点
         1 ）数组名作为函数的参数，是地址的传递，在函数中可以直接修改数组的内容
         2）用数组名作为函数参数，会丢失数组长度，所以用数组名作为函数的参数，要传递数组名的同时，尽量把数组长度也传过去

         3）函数形参中定义的数组的长度，和实参数组的长度尽量保持一样，否则可能会有问题
         4）通常情况下形参的数组长度是不指定的，它的长度有实参的来决定的

         5）函数的形参数组的类型，要和实参数组的类型要一致

  一  数组的基本概念


1、什么是数组？

    一组 相同类型 的 若干 个 有序 的数据集合

2、数组的名词：

    1）数组名:带表一组相同类型若干个有序的数据集合（）
    2) 数组元素：构成数组的每一个元素
    3）下标：数组是有序的，下标有序，用来标识每个元素在数组中的位置
    4）数组的维度： 元素下标的个数
    5）数组的长度：集合中元素的个数

3、分类：
   
    1）按内容分类：数值型数组（整型、实型）、字符型数组、指针数组、构造数组

二  一维数组


   1、什么是一维数组？

       每一个元素都是基本类型（int float char）的数据

       数组的使用流程：先定义--->初始化--->引用（使用）

   2、一维数组的定义？

       格式：

           数据类型   数组名[长度];

                          1+2  4+5
           int a[10];
           定义了一个整型的数组a
           另一种描述：定义了了一个长度为10，每个元素都只能存放int型数据的数组  数组名是a

           int 表示数组中每个元素的类型都必须是int型

       注意:

          1）a是数组的名称，a需要遵守标示符的命名规范
             （1）字母、数字、_ 、美元符号组成，不能以数字开头，不能和关键字重名，严格区分大小写

          2）数组长度不能使用变量，
  
             int n=5;  int arr[n]; 这种写法C规范不可以，但是Xcode可以

          3）数组长度可以使用宏定义
   
             #define N 5; int arr2[N+3];这种写法是可以的

         
          4）数组名不能和其他变量重名

             int a;
             int a[10];错误的

          5）可以一次定义多个数组

             int a[10],b1[3]; 表示定义了两个整型数组，第一个数组名a,能存放10个int型的数据，第二个数组 b1 能存放3个int型数据

          6）数组定义后，只能存放定义类型的数据
            int a[10]; 只能存放int型数据

          7）可以定义变量的同时，定义数组
            
             int a,b,arr[10];
三 数组的初始化
1、数组的初始化

变量的初始化， 给变量赋初值
数组的初始化，给数组中的每个元素都要进行初始化；

2、数组的初始化的方法

     数组如果定义完成以后，没有进行初始化，这个时候，元素的值是随机数（垃圾值）

     初始化的格式：int 数组名[长度]={值1,值2,.....}

    1）定义的同时进行初始化     int a=10;

       （1)完全初始化

            int a[5]={1,2,3,4,55};
            注意：初始化数值得个数可以小于长度，但是不能大于长度

            不指定数组长度的完全初始化
            int a3[]={1,2,3}; //定义一个数组，数组的长度由初始化的元素的个数决定的

            误区：
                a3={1,2,3};   错误
                a3[]={1,3,4}; 错误

        (2)部分初始化

            int a1[5]={1};   //优先把1初始化给第一个元素

           指定元素的部分初始化

            int a2[5]={[2]=1,[4]=100};
            // 给第三个元素初始化为1  给第5个元素初始化为100
  


    2）先定义，后初始化

       误区：
         int a1[5];
         a1[]={1,2,3}; 错误的
         a1={1,2,3};   错误的


       正确用法：每个元素逐个进行初始化

         a1[0] = 10;
         a1[1] = 100;
         a1[2] = 1000;
         a1[3] = 10000;
         a1[4] = 1;

         a1[5] = 0; //错误的


   3、数组的引用

     数组的引用，其实就是获取数组中存储的内容
     可以通过数组下标，来访问数组中的每一个元素
     如果说数组长度为n , 下标的最大值 n-1,最小是 0
     如果说某个数组的下标最大值是n,数组最少有 n+1个元素

     格式: 数组名[下标]

     int a[5]={1,2,3,4,5};
     char c[34] 下标取值范围 0-33;
     数组第一个元素 a[0]    1
                  a[1]    2
          3）数组长度可以使用宏定义
   
             #define N 5; int arr2[N+3];这种写法是可以的

         
          4）数组名不能和其他变量重名

             int a;
             int a[10];错误的

          5）可以一次定义多个数组

             int a[10],b1[3]; 表示定义了两个整型数组，第一个数组名a,能存放10个int型的数据，第二个数组 b1 能存放3个int型数据
  四  数组的练习


#include <stdio.h>

int main()
{
   
   
    //定义一个数组
    int a[50];
    //通过for循环给数组赋值
    for (int i=0; i<50; i++) {
        a[i]=i+1;
    }
   
   
     
     //打印数组的每一个值，遍历
     for (int i=0; i<50; i++) {
         printf("%d\t",a[i]);     }
          return 0;
            }
五  数组的储存方式
#include <stdio.h>
int main()
{
    //1、数组的存储方式
    //每个地址相差4个字节
    int a[3]={13,34,438};
    //数组的首地址 = a[0]的地址 = a
    //所以，数组名存放的实际上是数组的首地址
   
    printf("a = %p \n",a);
    printf("a[0]=%p\n",&a[0]);  //地址最低
    printf("a[1]=%p\n",&a[1]);
    printf("a[2]=%p\n",&a[2]);  //地址最高
   
   
   
    //2、数组的长度计算方法
    // 数组在内存中占用的字节数：sizeof(int)*n个数  = sizeof(数组名)
    printf("数组占用的字节数：%ld\n",sizeof(a));
    //计算数组的元素个数
    printf("数组的个数：%ld\n",sizeof(a)/sizeof(int));
   
    //
    int a1[]={1,2,3,4,4,5,6,6,70,24,5,6,6,89};
    int length = sizeof(a1)/sizeof(int);
    //长度是14 ：0-13
    printf("length:%d\n",length);
    //访问数组的下标，超过了最大下标
    //约错了对象，越界程序会给出警告，但是不会报错，千万要注意越界
    //printf("a[14]=%d\n",a1[14]); //越界
    return 0;
}
练习 2
求数组中的最大值
#include<stdio.h>

void tese2()
{
   
    int a[10];  int max=-1;//默认max是最大值
    for (int i=0;i<10 ; i++)
    {
        printf("请输入一个整数");
        scanf("%d",&a[i]);//接受整数存放数组里面
    }
    for (int j=0; j<10; j++) {
        if (a[j]>max) {
//拿当前的值和前面的笔记如果大于前面的值，就赋值给前面的数

            max=a[j];
        }
        
    }
    printf("最大的数是%d\n",max);
}


int main(){
   
   
   
   
    tese2();
   
   
   
   
   
   
    return 0;
}

3 // 冒泡排序的题目
#include<stdio.h>

void sortArray(int a[],int len)
{
    //定义变量
    int temp;
    //循环控制趟数
    for (int i=0; i<len-1; i++) {
        
        //控制两两比较，比较的次数  0 ~ len-1-i;
        
        for (int j=0; j<len-1-i; j++) {
            // a[j]>a[j+1]  交换
            if (a[j]>a[j+1]) {
                //让a[j]和a[j+1]交换
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}
int main()
{

    int arr[10]={34,66,32,63,76,45,53,32,98,99};
    //打印排序前的
    for (int i=0;i<10;i++) {
        printf("%d\t",arr[i]);
    }

    printf("\n");
    //调用冒泡排序
    sortArray(arr, 10);
    printf("\n");
   
    //打印排序后的
    for (int i=0;i<10;i++) {
        printf("%d\t",arr[i]);
    }
   
    printf("\n");






    return 0;
}
注意点
         1 ）数组名作为函数的参数，是地址的传递，在函数中可以直接修改数组的内容
         2）用数组名作为函数参数，会丢失数组长度，所以用数组名作为函数的参数，要传递数组名的同时，尽量把数组长度也传过去

         3）函数形参中定义的数组的长度，和实参数组的长度尽量保持一样，否则可能会有问题
         4）通常情况下形参的数组长度是不指定的，它的长度有实参的来决定的

         5）函数的形参数组的类型，要和实参数组的类型要一致