博客主页：https://blog.csdn.net/weixin_46094737?type=blog
欢迎评论?留言 ?如有错误敬请指正！
本文由小学生廉原创，首发于 CSDN🙉🙉🙉
未来很长，值得我们全力奔赴更美好的生活！💞💞💞
首先上结论：
☆char类型数组地址空间大小为：1?
☆short类型数组地址空间大小为：2
☆int类型数组地址空间大小为：4
☆long类型数组地址空间大小为：4
☆long long类型数组地址空间大小为：8
接下来我们在编程中把它打印出来（以16进制数打印结果，#表示输出为16进制，p表示查询地址） 。
sizeof：地址大小?
#include <stdio.h>
int main()
{
int i;
char arr01_5[5]={10,11,12,13,14};//char类型数组的地址空间（房间容量为1）
printf("char类型的地址空间为：%d\n",sizeof(char));//每一个组数下标占1个字节（房间容量）
printf("arr01_[5]的地址空间为：%#p\n",&arr01_5[0]);//打印出数组下标0的地址空间（房间号）
printf("arr01_[5]的地址空间为：%#p\n",&arr01_5[1]);
printf("arr01_[5]的地址空间为：%#p\n",&arr01_5[2]);
printf("arr01_[5]的地址空间为：%#p\n",&arr01_5[3]);
printf("arr01_[5]的地址空间为：%#p\n",&arr01_5[4]);
for(i=0;i<5;i++)
{
printf("char类型数组下标%d的值为：%d\n",i,arr01_5[i]);
}
short arr04_5[5];//short类型数组的地址空间（房间容量为2）
printf("short类型数组的地址空间为：%d\n",sizeof(short));//每个数组下标占2个字节（房间容量）
printf("arr04_5[5]的地址空间为：%#p\n",&arr04_5[0]);
printf("arr04_5[5]的地址空间为：%#p\n",&arr04_5[1]);
printf("arr04_5[5]的地址空间为：%#p\n",&arr04_5[2]);
printf("arr04_5[5]的地址空间为：%#p\n",&arr04_5[3]);
printf("arr04_5[5]的地址空间为：%#p\n",&arr04_5[4]);
int arr02_5[5];
printf("int类型数组的地址空间为：%d\n",sizeof(int));
printf("arr02_[5]的地址空间为：%#p\n",&arr02_5[0]);
printf("arr02_[5]的地址空间为：%#p\n",&arr02_5[1]);
printf("arr02_[5]的地址空间为：%#p\n",&arr02_5[2]);
printf("arr02_[5]的地址空间为：%#p\n",&arr02_5[3]);
printf("arr02_[5]的地址空间为：%#p\n",&arr02_5[4]);
long arr03_5[5];
printf("long类型数组的地址空间为：%d\n",sizeof(long));
long long arr05_5[5];
printf("long long类型数组的地址空间为：%d",sizeof(long long));
return 0;
} 打印结果如下：?
依据输出结果我们可以清晰的看到各个类型的数组空间大小（房间容量），简单明了。
利用函数调用数组求班级同学成绩的平均值：
#include <stdio.h>
void update(float arr_01[],int n);
float arr_avg(float arr[],int n);
int main()
{
int i;
float avg;
float grade[4]={89.5,45.5,89.5,60.5};
for(i=0;i<4;i++)
printf("当前第%d位同学的成绩为%.1f\n",i+1,grade[i]);
update(grade,4);//实参中直接调用（函数名字，元素数量）
for(i=0;i<4;i++)
printf("修改后第%d位同学的成绩为%.1f\n",i+1,grade[i]);
avg=arr_avg(grade,4);//实参中直接调用（函数名字，元素数量）无需重新指定类型，因为前面已经声明啦!
printf("平均成绩为:%.1f",avg);
return 0;
}
void update(float arr_01[] ,int n)
{
int i;
for(i=0;i<4;i++)
{
printf("请重新输入第%d位同学的成绩：\n",i+1);
scanf("%f",&arr_01[i]);
}
}
float arr_avg(float arr[],int n)
{
int i;
float ret=0;
for(i=0;i<n;i++)
{
ret += arr[i];
}
ret /= 4;
return ret;
}数组中的元素逆序排列算法：
#include <stdio.h>
void swap_arr(int a[],int n);
int main()
{
int arr[5]={0};
int i;
for(i=0;i<5;i++)
{
printf("请输入第%d个元素的值\n",i);
scanf("%d",&arr[i]);
printf("第%d个元素的值arr[%d]=%d\n",i,i,arr[i]);
}
printf("\n");
swap_arr(arr,5);
for(i=0;i<5;i++)
{
printf("转换后第%d个arr[%d]=%d\n",i,i,arr[i]);
}
return 0;
}
void swap_arr(int a[],int n)
{
int i,temp;
for(i=0;i<n/2;i++)
{
temp=a[n-i-1];
a[n-i-1]=a[i];
a[i]=temp;
}
}核心算法就是数组中的第一个元素和最后一个元素交换，第二个元素和最后一个元素交换.....以此类推：
for(i=o;i<n/2;i++)?
????????temp=a[n-i-1];
?????a[n-i-1]=a[i];
? a[i]=temp;
在此基础上我们可以将此算法进行升华得到冒泡算法的核心。
?冒泡排序算法：
冒泡排序。就是它进行两个两个的比较如果发生了逆序，就进行交换。这里以大的数字放在最右边，小的在最左边先看一组数字：3，10，5，16，9，12，7
进行排序就是两两比较
第一次 3，5，10，9，12， 7， 16
第二次 3，5，9，10，7， 12 ，16
第三次 3，5，9，7，10 ，12 ，16
第四次 3，5，7，9，10， 12， 16
从这里我们就可以看出端倪，在整个的排序过程中，相邻两个进行比较的时候我们要使用一次内部循环，在进行排序操作的时候我们还需要进行一次外部循环，才可以最后得出结果。
源代码：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void swap(int arr_01[],int n);
void fuzhi(int arr_03[],int n);
int main()
{
int i;
int arr[10]={0};
fuzhi(arr,10);
for(i=0;i<10;i++)
{
printf("排序前(随机产生)：arr[%d]=%d \n",i,arr[i]);
}
swap(arr,10);
printf("\n");
for(i=0;i<10;i++)
{
printf("排序后(升序排列)：arr[%d]=%d \n",i,arr[i]);
}
return 0;
}
void fuzhi(int arr_03[],int n)
{
int i;
srand(time(0));
for(i=0;i<n;i++)
{
arr_03[i]=rand()%99+1;
}
}
void swap(int arr_01[],int n)
{
int i,j,temp;
for(i=0;i<n-1;i++)//比较的轮数
{
for(j=0;j<n-1;j++)//每进行一轮比较，前一个小的元素和后一个较大的元素交换一下位置
{
if(arr_01[j]>arr_01[j+1])
{
temp=arr_01[j];
arr_01[j]=arr_01[j+1];
arr_01[j+1]=temp;
}
}
}
} 运行结果：
核心的算法就是利用了两次for循环：
for(i=0;i<n-1;i++)//比较的轮数
{
for(j=0;j<n-1;j++)//每进行一轮比较，前一个小的元素和后一个较大的元素交换一下位置
{
if(arr_01[j]>arr_01[j+1])
{
temp=arr_01[j];
arr_01[j]=arr_01[j+1];
arr_01[j+1]=temp;
}
}
}?起初我一直不太理解为啥要用到两次循环，这里借用一位博主的巧妙比喻，理解之后，便豁然开朗。
首先:嵌套是这么理解的。比如你有10棵树,每天都去检查是否生虫子了,连续检查一个月(30天)
循环就是这样:
for(j=1;j<=30;j++)
{
????????for(i=1;i<=10;i++)
????????{
????????????????print("今天是第%d天, 正在检查第%d棵树",j,i);
????????}
}
外层循环用户控制天,内层循环用于控制树,缺一不可，第一天检查十遍,第二天检查十遍,...
也就是j=1的时候内层循环执行一遍,j=2的时候内层循环执行一遍...
对于冒泡排序，可以这样考虑：
外层循环式控制一共有多少个泡需要排序, 这个当然要用循环，内层循环控制把某一个泡放到正确的位置, 这个也要用循环, 因为这个泡要和所有未排序泡比较一遍, 然后才能知道自己应该处的位置
这里有两个点,明白了的话,这道题就明白了。
1. 外层循环: 仅仅控制一共有多少个泡需要排序, 比如代码中a[10], 一共是10个元素
2. 内层循环: 仅仅控制把当前最大的泡放到最后, 也就是一次内层循环,仅仅把最大的那个泡放到最后了而已
把1和2综合起来看，当j=0时,把a数组10个元素中最大的泡放到最后，当j=1时,把a数组10个元素中第二大的元素放到倒数第二个位置，依次类推..直到第10大的元素,即最小的元素放到正数第一个位置，可以这样测试一下,会更加清晰,把第一个循环去掉, 内层循环改为:
for(i=0; i< 10; i++) 相当于仅执行上述j=0的一次内层循环, 这个循环的作用是把最大的元素放到最后。
?这是我把外层循环注释掉之后的结果，只是把最大的“泡”放到了最后，其他位置没有更改。
作业1 找出数组中的最大值
#include <stdio.h>
double swap(double arr_01[],int n);
int main()
{
double i;
double arr[5]={1,2,6,4,4.5};
i=swap(arr,5);
printf("数组中最大值元素为：%f",i);
return 0;
}
double swap(double arr_01[],int n)
{
double max=0;
int i;
for(i=0;i<n;i++)
{
if(max<arr_01[i])
max=arr_01[i];
}
return max;
}
?本题要点就在于：
?? ?if(max<arr_01[i])
?? ??? ??? ?max=arr_01[i];
理解这两小段代码，问题自然迎刃而解啦。
?作业2?输出数组中最大值与最小值的差
#include <stdio.h>
double swap(double arr_01[],int n);
int main()
{
double i;
double arr[5]={1,2,7.5,4,4.5};
i=swap(arr,5);
printf("%f",i);
return 0;
}
double swap(double arr_01[],int n)
{
double min=1000,max=0,sum=0;
int i;
for(i=0;i<n;i++)
{
if(max<arr_01[i])
max=arr_01[i];
if(min>arr_01[i])
min=arr_01[i];
}
sum=max-min;
return sum;
}本题要点和上一题极其相似，深刻理解两个if的判断条件，问题也就迎刃而解啦
?? ?if(max<arr_01[i])
?? ??? ??? ?max=arr_01[i];
?? ??? ?if(min>arr_01[i])
?? ??? ??? ?min=arr_01[i];
其中有一点需要注意，min的初始值不能为0，因为如果为0的话，如果数组中没有负数的话，那么min的值会始终等于0，?就失去了寻找数组中的最小值。如果数组中有负数的话，min初始值为0也不会有影响。总结一点：min的初始值需要比数组中的最小值要大，即可。
作业3??冒泡排序优化，提示，如果发现某一轮不需要进行任何交换，则可以提前终止循环。
#include <stdio.h>
void swap(int arr_01[],int i);
int main()
{
int i,arr[5]={5,2,100,54,150};
swap(arr,5);
for(i=0;i<5;i++)
{
printf("交换后第%d个元素的值arr[%d]=arr[%d]\n",i,i,arr[i]);
}
return 0;
}
void swap(int arr_01[],int n)
{
int i,j,temp;
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1;j++)
{
if(arr_01[j]>arr_01[j+1])
{
temp=arr_01[j];
arr_01[j]=arr_01[j+1];
arr_01[j+1]=temp;
}
else if(arr_01[j]<arr_01[j+1]||(arr_01[j]=arr_01[j+1]))
continue;
}
}
}运行结果:
作业4?输入10个数到数组t中，再输入x，如果有与x相等的数组元素，输出该数组元素的下标；否则，输出-1。
#include <stdio.h>
int main()
{
int i,x,t[4]={0};
for(i=0;i<4;i++)
{
printf("请输入数组t中第%d个元素的值(以回车结束)：t[%d]=\n",i,i);
scanf("%d",&t[i]);
}
for(i=0;i<4;i++)
{
printf("数组t中第%d个元素的值：t[%d]=%d\n",i,i,t[i]);
}
printf("请输入x的值：");
scanf("%d",&x);
for(i=0;i<4;i++)
{
if(x==t[i])
printf("%d\n",i);
else
printf("-1\n");
}
return 0;
}运行结果：
作业5?产生一个由10个元素组成的一维数组，并输出（由随机函数产生1-99），然后进行升序排序。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void swap(int arr_01[],int n);
void fuzhi(int arr_03[],int n);
int main()
{
int i;
int arr[10]={0};
fuzhi(arr,10);
for(i=0;i<10;i++)
{
printf("排序前(随机产生)：arr[%d]=%d \n",i,arr[i]);
}
swap(arr,10);
printf("\n");
for(i=0;i<10;i++)
{
printf("排序后(升序排列)：arr[%d]=%d \n",i,arr[i]);
}
return 0;
}
void fuzhi(int arr_03[],int n)
{
int i;
srand(time(0));
for(i=0;i<n;i++)
{
arr_03[i]=rand()%99+1;
}
}
void swap(int arr_01[],int n)
{
int i,j,temp;
for(i=0;i<n-1;i++)//比较的轮数
{
for(j=0;j<n-1;j++)//每进行一轮比较，前一个小的元素和后一个较大的元素交换一下位置
{
if(arr_01[j]>arr_01[j+1])
{
temp=arr_01[j];
arr_01[j]=arr_01[j+1];
arr_01[j+1]=temp;
}
}
}
} 运行结果：
?今日总结完毕，over，碎觉！！！