1.用数组存储10个整型数，通过键盘输入一个数，找出该数在数组中的下标值；
/*1.用数组存储10个整型数，通过键盘输入一个数，找出该数在数组中的下标值；*/
#include <stdio.h>
int main(void)
{
int nums[10] = {11,22,33,44,55,66,77,88,99,100};
int i;
int n;
//遍历数组的数打印给用户
printf("数组中的元素为:");
for(i = 0;i < 10;i++)
{
printf("%-3d",nums[i]);
}
printf("\n");
//让用户输入一个整数
printf("请输入一个整数:");
scanf("%d",&n);
for(i = 0; i < 10;i++) //遍历数组的元素
{
if(nums[i] == n)
{
break; //找到与之匹配的元素,跳出循环
}
}
if(i < 10) //下标小于10说明找到了输入的数
{
printf("该数组的下标值为: %d\n",i);
}
else
{
printf("数组中未找到该数。\n");
}
return 0;
}
2.通过键盘输入 10 个学员成绩，
1）输出不及格学员的成绩和下标。
2）求最高分的下标值
3）求最低成绩的下标值
4）求总成绩及平均成绩
/*2.通过键盘输入 10 个学员成绩，
1）输出不及格学员的成绩和下标。
2）求最高分的下标值
3）求最低成绩的下标值
4）求总成绩及平均成绩 */
#include <stdio.h>
int main(void)
{
float score[10] = {0};
int i = 0;
for(i = 0;i < 10;i++)
{
printf("请输入第%d个学生成绩:",i+1);
scanf("%f",&score[i]);
}
float sum =0;
int maxid = 0,minid = 0;
for(i = 0;i < 10;i++)
{
sum += score[i];
if(score[i] < 60)
{
printf("下标为%d的学生成绩不合格,成绩为:%.1f\n",i,score[i]);
}
if(score[maxid] < score[i]) //这里当最大值小于数组的元素i,则将i赋值给maxid
{
maxid = i;
}
if(score[minid] > score[i]) //当最小值minid大于数组元素i,则将数组i赋值给minid
{
minid = i;
}
}
float ave = sum / 10; //求均值
printf("=================================\n");
printf("最高分: %.1f,下标为: %d\n",score[maxid],maxid);
printf("最低分: %.1f,下标为: %d\n",score[minid],minid);
printf("总成绩: %.1f,平均成绩为: %.1f\n",sum,ave);
return 0;
}
3.利用冒泡的排序思想将数据由大到小排序；
数据的典型应用--数据排序
冒泡排序
向后冒泡（算法思想）：1.两两进行数据交换，一次排序只排好最大的一个数，第二次是次大以此类推，交换（两两进行交换）
向前冒泡：认为第一个数据已经排好，所有数据和第一个数据进行交换，第二次所有的数和第二个数 据进行交换（固定好一个数据其他数据进行交换）到n-2数据排序结束
1)向后冒泡：（第一次把最大的数排号，第二次把次大的排序...以此类推向后冒泡）
数组不能越界
（全部比较数据会减少）
（依次排序过程两辆交换，一次排好一个数）
（嵌套循环经过多次）
（每完成一次数据减少)7 4 6 2 3 8 1 5
1. 一次排序只排好一个数，针对 n 个数，最差情况需要 n -1 次排序就可以排好;
2. 每次排序将相邻两个数据两两比较,将较大/较小的数向后交换，等所有的数据都比较完毕，较大/较小的数就会出现在最后，这也是该数应该有的位置。也就是说 排好了一个数;
3. 在剩余的数据中，再次应用第2步的操作，直到只剩下一个数。
#include <stdio.h>
int main(void)
{
int a[] = {7,4,6,2,3,8,1,5};
int n = sizeof(a) / sizeof(a[0]);
int i = 0,j = 0;
for(i = 0; i < n; i++)
{
printf("%3d",a[i]);
}
printf("\n");
for(i = 0; i < n-1; i++)
{
for(j = 0; j < n-1 - i;j++)
{
if(a[j] > a[j+1]) //前一个比后一个元素大,进行交换
{
int t = a[j];
a[j] = a[j+1];
a[j+1]= t;
}
}
}
printf("========排序后========\n");
for(i = 0; i < n; i++)
{
printf("%3d",a[i]);
}
printf("\n");
return 0;
}2)向前冒泡：向前冒泡从第二个元素开始和第一个数（固定数）比较，位置不动，先把最小的排出来在（认为一个数最小开始比较）
1. 一次排序只排好一个数，针对 n 个数，最差情况需要 n -1 次排序就可以排好;
2. 每次排序假定第一个数据是最大/最小的.用第一个数据之后的所有数据和第一个数据比较，遇到较大/较小的数据和第一个数据交换，访问完所有的数据，最前面的数据就排好了。
3. 在剩余的数据中，再次应用第2步的操作，直到只剩下一个数。
#include <stdio.h>
int main(void)
{
int a[] = {7,9,1,4,5,8,3,2,6};
int n = sizeof(a) / sizeof (a[0]); //计算数组元素的总数,一个很好用的公式
int i = 0,j = 0;
for(i = 0; i < n; i++)
{
printf("%3d",a[i]); 打印数组元素，%3d指定宽度为3，不足部分用空格填充
}
printf("\n");
for(i = 0; i < n-1;i++) // 外层循环用于控制排序次数
{
for(j = i+1; j < n; j++) //内层循环实现每一次排序,找到从i+1到n-1的元素
{
if(a[j] < a[i]) //若找到更小元素,更新下标也就是索引
{
int t = a[j];
a[j] = a[i];
a[i] = t;
}
}
}
for(i = 0; i < n; i++)
{
printf("%3d",a[i]);
}
printf("\n");
return 0;
}冒泡排序是排序中最简单的(?)，当然也是效率最低的，她一次只排好一个数
区别:思想上是有一点点区别的,当然最后结果是一致的
向后冒泡：是通过比较和交换相邻元素来逐渐将最大的元素移动到数组的末尾。
向前冒泡：通过在每次外层循环中找到未排序部分的最小元素，并将其移动到未排序部分的起始位置。
