1.数组名
代码语言：javascript复制//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]=%pn", &arr[0]);//首元素的地址
// printf("&arr=%pn", &arr);
// //输出结果是
// // &arr[0]=00E1F8E0
// //&arr = 00E1F8E0
// //可以发现两个地址一样
//
//
// return 0;
//}
//其实数组名就是数组首元素的地址
//int main()
//{
// int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//
// printf("%dn",sizeof(arr));//打印的字节是40
// printf("%dn", 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]=%pn", &arr[0]);//数组首元素的地址
// printf("arr =%pn", arr);//也是数组首元素的地址
// printf("&arr =%pn", &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] =%pn", &arr[0]);//数组首元素的地址
printf("&arr[0] 1=%pn", &arr[0] 1);
printf("arr =%pn", arr );
printf("arr 1 =%pn", arr 1);//也是数组首元素的地址
printf("&arr =%pn", &arr);
printf("&arr 1 =%pn", &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] =%pn", &arr[0]);---整型的地址取出来，它的类型是int*
printf("&arr[0] 1=%pn", &arr[0] 1);
printf("arr =%pn", arr);-----类型也是int *
printf("arr 1 =%pn", arr 1);
printf("&arr =%pn", &arr);-----与上面的两种类型不一样
printf("&arr 1 =%pn", &arr 1);*/
//类型不一样，指针 1或者解引用就不一样数组名的地址就是数组首元素的地址，arr和&arr[0]
如果是&arr，那么这个就是整个数组的地址了---&数组名
2.使用指针访问数组
代码语言：javascript复制//那我们能使用指针的方式访问数组吗？
//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.一位数组传参的本质
代码语言：javascript复制/*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=%dn",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=%dn", 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=%dn", sz1);//10
//
// test(arr,sz1);//将元素个数传过去
// return 0;
//}4.冒泡排序
代码语言：javascript复制//冒泡排序
//思想：两两相邻的元素比较，不满足顺序就交换，满足顺序就找下一对
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=%dn", 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*都是一级指针
那么什么是二级指针呢？
代码语言：javascript复制//对二级指针的介绍
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类型数据的指针。这个数组可以存储指向整数的指针，可以是指向整数变量的指针，也可以是指向整数数组的指针。
例如：
代码语言：javascript复制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.指针数组模拟二维数组
代码语言：javascript复制//用指针数组模拟一个二维数组
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的数字，然后再解引用找到那个人数
