嵌入式开发学习（第二阶段 C语言基础）

冒泡排序

• 排序思想（向前冒泡）：
  • 一次只排好一个数，针对n个数，最差情况需要n-1次就可以排好
  • 每次排序假定第一个元素是最大或者最小的，用第一个元素的后面的元素一一与第一个元素比较，遇到较大或者较小的和第一个元素交换，访问完数组的最后一个元素，就排好了一个数。
  • 在余下的数中，再次应用第2步的操作，直到只剩下1个数。
• 动态演示

• 推理：

  例如：将5,4,3,2,1冒泡排序为1,2,3,4,5

  排序演示:

  第1轮：5,4,3,2,1 →4,3,2,1,5比较4次＝数组长度5·轮数1

  第2轮:4,3,2,1, 5→3,2,1,4,5比较3次＝数组长度5-轮数2

  第3轮：3,2,1,4,5→2,1,3,4,5比较2次＝数组长度5-轮数3

  第4轮：2,1,3,4,5→1,2,3,4,5比较1次=数组长度5-轮数4

  第0轮：5,4,3,2,11→4,3,2,1,5比较4次＝数组长度5-轮数0-1

  第1轮：4,3,2,1, 5→3,2,1,4,5比较3次=数组长度5-轮数1-1

  第2轮:3,2,1,4,5→2,1,3,4,5比较2次＝数组长度5-轮数2-1

  第3轮:2,1,3,4,5→1,2,3,4,5比较1次＝数组长度5-轮数3-1·

• 总结：

  • 案例涉及到5个数的排序，排序了4轮，得到：轮数=元素个数（数组大小）-1，我们可以通过一个外层for循环实现轮数的遍历。
  • 案例涉及的每一轮中数列的排序次数，得到：次数=元素个数-轮数[-1]，
    ，我们可以通过一个内层for循环实现每一轮次数的遍历。
  • 每一次比较过程中，两个数涉及到位置交换，比如a=3,b=4，交换ab的数据变为a=4,b=3，应该如何实现：
    • 引入一个临时变量temp，将a的值赋值给temp，inttemp=a;
    • 将b的值赋值给a，a=b;
    • 将temp的值赋值给b，b=temp;

• 代码

  /*************************************************************************
    > File Name:    demo01.c
    > Author:       刘孟丹
    > Description:  冒泡排序
    > Created Time: 2025年05月13日 星期二 09时24分39秒
   ************************************************************************/
  
  #include <stdio.h>
  
  int main(int argc,char *argv[])
  {
      int arr[10];
  
      int i,j,temp;
      printf("请输入10个整数：\n");
  
      int len = sizeof(arr) /sizeof(arr[0]);
  
      for(i = 0;i< len ;i++)scanf("%d",&arr[i]);
  
      printf("\n");
  
      for (i = 0;i < len -1;i++)
      {
          //int flag = 0;
          for(j = 0; j < len - i - 1;j++)
          {
              
              if(arr[j] > arr[j+1])
              {
                  temp = arr[j + 1];
                  arr[j + 1] = arr[j];
                  arr[j] = temp;
                  
              }
              
  
          }
          //if(flag == 0)break;
      }
          printf("冒泡排序后的数列：\n");
          for(i = 0;i < len; i++)
          printf("%-4d",arr[i]);
          printf("\n");
      return 0;
  }

• 运行结果
  

二维数组

定义

二维数组本质上是一个行列式组合，也就是说二维数组由行和列两部分组成。属于多维数组。二维数组数据通过行和列解读（先行后列）

二维数组可被视为一个特殊的一维数组，也就是说，当一个数组的元素是一维数组的时候，这个数组就是二维数组。

(数组的元素的类型可以是数组类型）

语法

数据类型 数组名 [行数][列数];

行数：外层数组的数组容量

列数：内层数组的数组容量

说明

• 二维数组在初始化的时候，可以省略行数，系统会通过初始化后的数据自动推断行数。
• 二维数组和一位数组一样，也可以部分初始化，未初始化的元素使用0(整型和浮点型)、\0（字符型，\0对应的ASCII是O)，NULL(指针相关)
• 二维数组在初始化的时候，不能省略列数，否则编译报错。

举例

int arr[3][3] = {{11,12,13},{21,22,23},{31,32,33}};     // 正确，等价于下面写法
int arr[][3]  = {{11,12,13},{21,22,23},{31,32,33}};     // 正确，二维数组初始化的时候可以省略行数，推荐写法

int arr[3][3] = {{11,12},{21,22,23},{31}};             // 正确，确实部分根据情况补0、\0、NULL，补什么由数据类型决定
int arr[3][3] = {{11,12,0},{21,22,23},{31,0,0}};       // 正确，等价于上面写法

int arr[3][3] = {0};                                   // 正确，所有位置使用0补齐
int arr[3][3] = {};                                    // 正确，所有位置使用0补齐
int arr[3][3] = {11};                                  // 正确，除了第0行第0列使用11以外，其他位置使用0补齐

int arr[][]   = {{11,12,13},{21,22,23},{31,32,33}};    // 错误，编译报错，不能省略列数
int arr[3][]  = {{11,12,13},{21,22,23},{31,32,33}};    // 错误，编译报错，不能省略列数

注意：在C语言中，二维数组在计算机存储顺序是按行进行的，即第一维（行）下标变化慢，第二维的（列）下标变化快。

内存存储

应用场合

主要是应用对行列有要求的情况。比如我们现在要存储西安粤嵌所在班级的成绩.

还有就是字符数组的应用，比如用数组存储学生的姓名。

double score[28] = {..}：一维数组初始化

double score[5][40]：二维数组初始化

double score[6][4][40]={22,22,22}：三维数组初始化

特殊写法

• 下标可以是整型表达式。如：a[2-1][2*2-1] → a[1][3]

• 下标可以已经有值的变量或者或者数组元素，如： a[2*x-1][b[3][1]]

• 数组元素可以出现在表达式中，如： b[1][2] = a[2][3]/2

注意：使用数组元素的下标应在已定义数组的大小范围内；应注意区别定义数组大小和引用数组元 素的区别。

初始化

• 分行给二维数组赋初值

  int arr[3][4] = {{11,12,13,14},{21,22,23,24},{31,32,33,34}};

• 可将所有数据写在一个花括号内，按照排列顺序对元素赋值

int arr[3][4] = {11,12,13,14,21,22,23,24,31,32,33,34};

• 可对部分元素赋初值，其余未赋值部分自动填充数值类型默认值-0|字符型默认值-\0|指针类型-NULL

int arr[3][4] = {{11},{21,22},{31}};

• 若对全部元素赋初值，自定义数组时可以省略第1维数组的长度(行数)，第2维数组的长度(列数)必须指明。

int a[][4] = {11,12,13,14,21,22,23,24,31,32,33,34};

• 在分行赋初值时，也可以省略第1维的长度(行数)。

int arr[][4] = {{11,12,13},{0},{0,10}};

案例

案例1

• 需求：二维数组的遍历

• 分析：

  • 二维数组的遍历需要使用嵌套for循环，外层循环遍历行，内层循环遍历列
  • 取值：

  数组名[行号][列号];

  • 赋值

    数组名[行号][列号] = 值;

• 代码：

  /*************************************************************************
    > File Name:    demo02.c
    > Author:       刘孟丹
    > Description:  
    > Created Time: 2025年05月13日 星期二 11时32分45秒
   ************************************************************************/
  
  #include <stdio.h>
  
  int main(int argc,char *argv[])
  {
      int arr[][3] = {{11},{21,22},{31,32,33}};
  
      int row = sizeof(arr) / sizeof(arr[0]);
      int col = sizeof(arr[0]) / sizeof(arr[0][0]);
  
      for(int i = 0; i < row ; i++)
      {
          for(int j = 0; j < col ; j++)
          {
              printf("%-3d",arr[i][j]);
          }
      }
      printf("\n");
      return 0;
  }

• 运行代码

  

案例2

• 需求：矩阵的转置

• 分析：

  • 所谓的转置，就是原本的列变行，行变列

  

• 代码

/*************************************************************************
  > File Name:    demo03.c
  > Author:       刘孟丹
  > Description:  
  > Created Time: 2025年05月13日 星期二 11时43分31秒
 ************************************************************************/

#include <stdio.h>
#define ROW 2
#define COL 3
int main(int argc,char *argv[])
{
    //定义循环变量i，j
    int i,j;

    int arr_before[ROW][COL] = {11,12,13,21,22,23};
    int arr_after[COL][ROW]= {0};

    int arr_before_row = sizeof(arr_before) / sizeof(arr_before[0]);
    int arr_before_col = sizeof(arr_before[0]) / sizeof(arr_before[0][0]);


    int arr_after_row = sizeof(arr_after) / sizeof(arr_after[0]);
    int arr_after_col = sizeof(arr_after[0]) / sizeof(arr_after[0][0]);
	// 通过嵌套for循环实现转置

    printf("转置前：\n");

    
    for(i = 0;i < arr_before_row; i++)
    {
        for(j = 0; j < arr_before_col; j++)
        {
            printf("%-4d",arr_before[i][j]);
		    arr_after[j][i] = arr_before[i][j];

            
        }
	    printf("\n");
    }

    printf("转置后：\n");
    for (i = 0; i < arr_after_row; i++)
   {
        for (j = 0; j < arr_after_col; j++)
            printf("%-4d",arr_after[i][j]);
        printf("\n");
   }
    printf("\n");


    return 0;
}

• 运行结果