1.数组名的理解

//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; 
//    //int *p=&arr[0];//把首元素的地址取出来放到p里面去--p就指向了数组里面的1
//    printf("&arr[0]=%p\n", &arr[0]);//首元素的地址
//    printf("&arr=%p\n", &arr);
//    //输出结果是
//    // &arr[0]=00E1F8E0
//    //&arr = 00E1F8E0
//    //可以发现两个地址一样
//
//    
//    return 0;
//}
//其实数组名就是数组首元素的地址


//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    
//    printf("%d\n",sizeof(arr));//打印的字节是40
//    printf("%d\n", sizeof(arr[0]));//打印的字节是4
//    
//
//    return 0;
//}
//但是有两个例外
//1.sizeof(数组名)--这里的数组表示整个数组，计算是整个数组的大小，单位是字节
//2.&数组名---也表示整个数组，取出的使整个数组的地址


//除此之外，所有的数组名都是数组首元素的地址

//产生疑问：整个数组的地址和数组首元素的地址有什么区别呢？
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//
//    printf("&arr[0]=%p\n", &arr[0]);//数组首元素的地址
//    printf("arr    =%p\n", arr);//也是数组首元素的地址
//    printf("&arr   =%p\n", &arr);//数组的地址
//    //输出结果是
//    // &arr[0]=0000002F78F0FD50
//    //arr     =0000002F78F0FD50
//    //& arr   =0000002F78F0FD50
//    return 0;
//}
//但是这三个地址真的没有差异吗？
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    printf("&arr[0]  =%p\n", &arr[0]);//数组首元素的地址
    printf("&arr[0]+1=%p\n", &arr[0]+1);


    printf("arr      =%p\n", arr );
    printf("arr+1    =%p\n", arr+1);//也是数组首元素的地址



    printf("&arr     =%p\n", &arr);
    printf("&arr+1   =%p\n", &arr+1);//数组的地址
    //输出结果是
    /*  &arr[0]      = 000000CA4590FC10
        & arr[0] + 1 = 000000CA4590FC14
        arr          = 000000CA4590FC10
        arr +     1  = 000000CA4590FC14
        & arr        = 000000CA4590FC10
        & arr +   1  = 000000CA4590FC38     */
    //不难发现，一个数组的地址+1跳过的是整个数组
    //单只数组首元素的地址+1跳过的是4个字节

    //所以我们&arr，&数组名的时候，取出的就是整个数组的地址

    return 0;
}
//以后在做题的时候一定要看看前面有没有sizeof或者前面加没加取地址符号
//数组名的地址就是数组首元素的地址，arr和&arr[0]
//如果是&arr，那么这个就是整个数组的地址了---&数组名


/*
printf("&arr[0]  =%p\n", &arr[0]);---整型的地址取出来，它的类型是int*
printf("&arr[0]+1=%p\n", &arr[0] + 1);


printf("arr      =%p\n", arr);-----类型也是int *
printf("arr+1    =%p\n", arr + 1);



printf("&arr     =%p\n", &arr);-----与上面的两种类型不一样
printf("&arr+1   =%p\n", &arr + 1);*/
//类型不一样，指针+1或者解引用就不一样

数组名的地址就是数组首元素的地址，arr和&arr[0]

如果是&arr，那么这个就是整个数组的地址了---&数组名

2.使用指针访问数组

//那我们能使用指针的方式访问数组吗？
//int main()
//{
//    int arr[10] = { 0 };
//    int sz = sizeof(arr) / sizeof(arr[0]);
//    //输入
//
//    int* p = &arr[0];//将数组首元素地址取出来放到指针变量p里面去
//
//    //将首元素的地址存在p里面甚至还能这样写
//    //int* p = arr；
//    for (int i = 0; i < sz; i++)
//    {
//        scanf("%d", p+i);//p放的是首元素的地址，p+i是下标为i的地址
//        //也可以这样写scanf("%d", arr+ i);
//    }
//    //输出
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d ", *(p+i));//解引用
//        //printf("%d ", *(arr+i));
//        //printf("%d ",i[arr] );
//    }
//    return 0;
//}

//*（arr+i）<====>arr[i]
//左边是指针的形式，右边是数组的形式
//arr+i是地址，地址解引用，找到的就是这个地址指向的那个数
//右边的是通过数组下标来访问对应的数字
//arr[i]<====>*（arr + i） <====>*（i+arr）<====> i[arr]
//这里的[]是操作符

//1.数组就是数组，是一块连续的空间，是可以存放一个或者多个数组的
//2.指针变量是一个变量，是可以存放地址的变量
//数组和指针不是一个东西
//但是可以使用指针来访问数组的

//为什么可以使用指针来访问数组呢？
//1.数组在内存中失败连续存放的
//2.指针的元素很方便的可以遍历数组，取出数组的内容

arr[i]<====>（arr + i） <====>（i+arr）<====> i[arr]

3.一维数组传参的本质

/*void test(int arr[])
{
    int sz2 = sizeof(arr) / sizeof(arr[0]);
    printf("sz2=%d", sz2);
}

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int sz1= sizeof(arr) / sizeof(arr[0]);

    printf("sz1=%d\n",sz1);//10

    test(arr);//arr是数组名，数组名表示的是数组首元素的地址
    return 0;//传过去的是地址，要用指针接收
}*/
//打印结果为
// sz1=10
//sz2 = 2
//为什么二者结果不一样

//test(arr)--一维数组传参的本质，传递的是首元素的地址
//所以形参即使写成数组的形式，本质上也是一个指针变量
//所以在函数的开头，我们要用指针接收

//数组传参的时候，形参可以写成数组，也可以写成指针‘
//写成数组的形式，最简单，是为了方便，容易接受这种语法
//但是即是写成数组的形式，本质上还是指针
/*void test(int* arr)
{
    int sz2 = sizeof(arr) / sizeof(arr[0]);//传过来的arr是首元素的地址，所以4/4=1
    printf("sz2=%d", sz2);
}

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int sz1 = sizeof(arr) / sizeof(arr[0]);//这里的arr是一整个数组的，所以是40/4=10

    printf("sz1=%d\n", sz1);//10

    test(arr);
    return 0;
}*/

//通常情况下数组传参我们会怎么做呢？
//
//void test(int* arr,int sz)
//{
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d", arr[i]);//printf("%d", *(arr+i));
//        //*(arr + i)=== arr[i]//i是从0开始的
//    }
//
//}
//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    int sz1 = sizeof(arr) / sizeof(arr[0]);//数组元素个数
//
//    printf("sz1=%d\n", sz1);//10
//
//    test(arr,sz1);//将元素个数传过去
//    return 0;
//}

4.冒泡排序

//冒泡排序
//思想：两两相邻的元素比较，不满足顺序就交换，满足顺序就找下一对 

input(int* arr, int sz)
{
    for (int i = 0; i < sz; i++)
    {
        scanf("%d", arr+i);//循环输入,arr放的是数组中首元素的 地址
    }
}

int count = 0;//定义全局变量
void bubble_sort(int*arr, int sz)
{
    //确定趟数,为什么是sz-1呢？
    //假设是9 8 7 6 5 4 3 2 1 0,
    //而9和相邻的数换位置要换9次，换完位置就是这样的
    //8 7 6 5 4 3 2 1 0 9
    //9已经换好了，可以不用动了，再就轮到8换到最后一个了
    //8换到最后一个要经历7次换位置

    //所以循环的次数就是sz-1次

    for (int i = 0; i < sz - 1; i++)
    {
        int flag = 1;//创建临时变量
        //每一趟内部的比较
        //第一趟的时候,10个元素历经9对比较
        //第二趟的时候，9个元素经历8对比较
        //每一趟结束后，待排序的数字少了一个，比较也就少了一对

        for (int j = 0; j <sz-1-i ;j++)
        //解释一下为什么这个循环的条件是j <sz-1-i 
        //，第一趟9对，第二趟8对，所以这个循环的条件不能一直是sz-1
        //这个条件一直在变化，第一趟的时候，i=0;那么sz-1-i=9
        //第二趟的时候需要8躺，i=1，sz-1-i=sz-1-1=8，所以这个循环的条件一定是sz-1-i
        //随着i的变化，这个内循环的趟输也要改变
        {

            count++;//一组数字进行比就加一
            if (arr[j]  > arr[j + 1])//如果前面大于后面，咱们就要进行交换
            {
                //交换了就将flag置为0,那么这个数还不是有序
                flag = 0;//如果arr[j]  > arr[j + 1]的话，那么就将flag定义为0
                //交换
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if (flag == 1)//如果flag的值仍然等于1，那么这个数组里面的数没有进行相邻数字的交换
        {//对冒泡排序的一种优化
            break;//如果给的数组是接近有序的状态或者有序的状态，这样提前判断可以减少排序的时间
        }
    }
}

void print_arr(int* arr, int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }

}


int main()
{
    int arr[10] = { 0 };
    //输入一些数字---这些数字存在乱序的现象，我们现在需要对其进行排序，排成升序
    //写一个函数完成数组的排序
    int sz = sizeof(arr) / sizeof(arr[0]);

    //输入数字到数组
    input(arr,sz);
    //使用冒泡排序,排序数组arr，sz个元素
    bubble_sort(arr,sz);

    //函数：打印数组的内容
    print_arr(arr,sz);//打印数组arr中那sz个元素
    printf("\ncount=%d\n", count);
    return 0;
}

//总结：
//两组循环，外循环的作用是：控制比较轮数，因为每次比较完
// 之后最大的数就会位居最后一位，这个数就不参加后面的交换了

//内循环的作用：控制每一轮内比较的次数，每轮只进行相邻两个数的交换

//这个冒泡排序的整个流程：1.先输入  2.再排序    3.再打印



//但是输入的数组是有序数组的话，但是还是要运行这个排序的函数，一轮进行下来，
//没有一对数进行交换，这样就导致代码运行的时间变长
//解决方法：创建临时变量flag=1，对输入的数组进行判断,如果输入数组满足这个内循环的条件语句并运行，那么
//就将flag的值置为0
//但是如果这个flag出了内循环第一轮的话还等于1的话，那么就说明这个输入的数组是个有序的数组，并不需要我们排序
//所以直接break,跳出
//对冒泡排序的一种优化

//我们可以定义一个全局变量count来测试一下两两比较了多少对，
//在内循环里面添加count++,如果进入循环的话就count++
//输入一组有序数列1 2 3 4 5 6 7 8 9 10
//打印出的count=9,及说明count 只进行了第一轮的9组比较，但是这组数组不满足if语句里面的条件
//所以并没有进入这个条件语句，故这个flag的值并没有被重新赋值，flag的值仍然是1，
//因为flag的值仍然为1，就满足后面的条件语句了，这个数组符合对有序数组的判断，多以就break了

5.二级指针

前面讲的int * **

double*

char*都是一级指针

那么什么是二级指针呢？

//对二级指针的介绍

int main()
{
    int a = 10;

    int *pa=&a;//pa存的是a的地址

    int **ppa=&pa;//这里的ppa就是二级指针变量，上面的pa就是一级指针变量
    //int *pa---->*说明pa是指针变量，int 说明pa指向的对象a是整型类型
    //a有地址，pa有地址，ppa也有地址，ppa指向的是pa
    //ppa的类型是int**    ，后面的*表示ppa是指针变量，前面的int*说明ppa指向的pa类型是int*
    printf("%d", **ppa);//打印结果就是a的值
    return 0;

}
//二级指针变量是用来存放一级指针变量的地址
//*ppa=pa----ppa解引用就是pa---因为ppa里面存的是pa的地址，
//**ppa==a---而pa里面存的是a的地址，所以ppa连续两次解引用得到的就是a的值

//**ppa===*pa===a

//什么时候用二级指针呢？
//当我们取出的是个一级指针变量的地址，你要把他存起来，就用二级指针

6.指针数组

指针都是地址，对于指针数组的话，数组内存放的都是指向某种类型的指针~地址

char arr[10]-----字符数组---存放字符的数组，元素是一个个字符

int arr[10]---整型数组---存放整型的数组，元素是一个个整型数字

那么

指针数组---存放指针的数组--数组的每个元素就是指针类型

char*arr[5]----存放字符指针的数组--放的都是指向字符类型的指针

int *arr[5]-----存放整型指针的数组

int*arr5说的就是一个包含5个元素的数组，每个元素都是指向int类型的指针.

在C语言中，int*arr[5] 声明了一个包含5个元素的数组，每个元素都是一个指向int类型数据的指针。这个数组可以存储指向整数的指针，可以是指向整数变量的指针，也可以是指向整数数组的指针。

例如：

int num1 = 10, num2 = 20, num3 = 30;

int* arr[5] = { &num1, &num2, &num3, NULL, NULL };------里面的都是指向int类型的指针

在这个例子中，arr数组的前三个元素分别指向变量num1、num2和num3的地址。数组的第四和第五个元素被初始化为NULL，表示它们不指向任何有效的内存地址。使用NULL初始化指针是一种良好的编程习惯，可以避免未定义行为。

int*arr[5] 还可以用于指向整数数组的指针，例如：

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

int array2[3] = {4, 5, 6};

int* arr[2] = { array1, array2 };

在这个例子中，arr数组的元素arr[0]和arr[1]分别指向array1和array2这两个整数数组的首地址。

需要注意的是，int*arr[5] 与int(*arr)[5] 是不同的。后者表示arr是一个指向包含5个整数的数组的指针，而不是一个包含5个整数指针的数组。

前面的是指针数组~什么指针类型的数组，int*就是这个指针数组里面元素的类型

而int a=10

int *pa=&a

这里的int指向的就是a的类型

而前面的int*指向的是p的类型，层层递进哦

而后面的也就是数组指针

int*指向的是一个整数

int a=10

int *pc=&a

这里pc的类型就是int *

7.指针数组模拟二维数组

//用指针数组模拟一个二维数组
int main()
{
    int arr1[5] = { 1 ,2 ,3 ,4, 5 };
    int arr2[5] = { 2,3,4,5,6 };
    int arr3[5] = { 3,4,5,6,7 };
    int* arr[] = { arr1, arr2, arr3 };//数组首元素的地址
    //单个整型元素的地址放到整型指针数组里面
    //访问arr里面的三个数组
    for (int i = 0; i < 3; i++)
    {//访问数组里面的元素,因为数组里面有5个元素，所以要打印5次
        for (int j = 0; j < 5; j++)
        {
            printf("%d ", arr[i][j]);//打印一行的元素
        }
        printf("\n");
    }

    return 0;
}
//创建三个一维数组，再将这三个数组放到一个指针数组里面
//arr[i]，拿到的是arr数组里面存放的另外三个一维数组的首元素地址
//[j]访问对应数组里面下标为j的元素
//这里面arr[i]=*(arr+i)
//打印后面的代码可以换成
//         *(*(arr+i)+j)
//*(arr+i)拿到的是一行的数组名，再+j，表示一行里面下标为j的数字，然后再解引用找到那个人数