C语言—数组一维(含冒泡排序)

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;
}

冒泡排序是排序中最简单的(?)，当然也是效率最低的，她一次只排好一个数

区别:思想上是有一点点区别的,当然最后结果是一致的

向后冒泡：是通过比较和交换相邻元素来逐渐将最大的元素移动到数组的末尾。
向前冒泡：通过在每次外层循环中找到未排序部分的最小元素，并将其移动到未排序部分的起始位置。