数组，冒泡排序

数组

1. 一维数组
2. 二维数组
3. 字符串和字符数组

# 1.一维数组及相关概念

我们之前所学过的数据类型都属于基本数据类型（整型、浮点型、字符型）。实际上C语言不仅仅可以操作基本数据类型，还可以操作构造数据类型（如结构体、数组等）。

## 1.1 什么是数组

**数组（Array）**是一组 **有序的、类型相同的数据的集合**，这些数据被称为数组的**元素（Element）**。

## 1.2 一维数组的定义

**数组定义的语法：**

存储类型  数据类型  数组名[数组长度] ;

**说明：**

**l** **存储类型：**auto，register，static，extern。若省略，相当于auto

**l** **数据类型：**可以是任何一种基本数据类型或构造数据类型

**l** **数组名：**每个数组都有一个名字，我们称之为**数组名**。**数组名**代表数组的**起始地址**。数组名应当符合标识符的命名规则，即以字母、数字、下划线组成，但不能以数字开头。

**l** **数组长度：所包含的数据的个数称为数组长度（Length）**。

​        数组长度一般只能是常量和常量表达式（但在C99新增了变长数组VLA）

**示例：**一个拥有10个元素的int型数组a

​    **int a[10];**

**注意：数组必须先定义后使用1.3一维数组元素的引用**

C语言规定数组必须逐个元素引用，不能整体引用。

数组元素由**索引**或**下标**（Index）标识，索引或下标从**0**开始。

**数组元素的表示方法：**

​    数组名[下标]

**例如：int a[10];**

​        其元素是a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]

**注意：**C语言对数组不作越界检查，使用时要注意

## 1.4  一维数组内存分配

​        数组在定义后，就在内存中划分了一块**连续的空间**用于存储数组。以int a[n]为例（n大于0）：这块空间的大小是sizeof(int)*n，划分成n块来顺序存储a[0]~a[n-1]。数组名代表这块空间的首地址（也就是a[0]的地址）

**示例：**定义一个数组，反序输出

int arr[10] = {};

在数组中输入10个元素

练习1：输入数字n，使用数组存储斐波那契数列前n项，并输出

练习2：从键盘输入10个学生的成绩，如果遇到大于100或者小于0的成绩需要提示输入错误重新输入。之后计算10个学生的总成绩和平均成绩。

```C
#include <stdio.h>

int main(){
    int score[10];
    for(int i=0; i<10; i++){
        scanf("%d", &score[i]);
        if(score[i] < 0 || score[i] > 100){
            printf("分数输入错误,请重新输入!\n");
            i--;
            continue;
        }
    }

    int totalScore = 0;   // stack -- 随机值
    for(int i=0; i < 10; i++){
        totalScore += score[i];
    }
    printf("学生总分为: %d\n", totalScore);
    printf("平均成绩为: %f\n", (float)totalScore/10);

    return 0;
}
```

## 1.6 变长数组

​        C99新增了变长数组（variable-length array, VLA）,允许使用变量表示数组的长度。

例如：

```C
int lenth = 5; 
int array[lenth];
```

注意：变长数组不能改变大小

​        变长数组中的”变”不是指可以修饰已创建数组的大小，一旦创建了变长数组，它的大小则保持不变。这里的”变”指的仅仅是：在创建数组时，可以使用变量指定数组的长度。

## 1.7 一维数组使用实例

### 1.7.1冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法描述：

①　 比较相邻的元素。如果第一个比第二个大（小），就交换它们两个；

②　 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大（小）的数；

③　 针对所有的元素重复以上的步骤，除了最后一个；

④　 重复步骤1~3，直到排序完成。

示例：从键盘输入10个各不相同的整数，存储在数组中，使用冒泡排序法将数组排序并输出

![冒泡排序]

```C
#include <stdio.h>
#define Max 10

int main(){
    int arr[Max], tmp;
    printf("请输入10个数:\n  ");
    for(int i=0; i<Max; i++){
        scanf("%d", &arr[i]);
    }

    // 1. 从数组中找出最大的元素(设置第一个元素为最大的元素)
    for(int i=0; i<Max-1; i++){
        for(int j=0; j<Max-1-i; j++){
            if(arr[j] > arr[j+1]){
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }

    printf("排序完成: ");
    for(int i=0; i<Max; i++){
        printf("%d  ", arr[i]);
    }
    printf("\n");

    return 0;
}
```

# 2. 二维数组及相关概念

​        在实际问题中有很多数据是二维的或多维的，因此 C 语言允许构造多维数组。

## 2.1多维数组

​        一维数组只有一个下标。具有两个或两个以上下标的数组称为多维数组（multidimensional array）。

其说明的一般形式如下： 

   <存储类型>  <数据类型>  <数组名>[<常量表达式1>][<常量表达式2>]…[<常量表达式n>] ；

例如：double  b[3][4][5];  //定义了一个三维双精度实型数组b

## 2.2 二维数组的定义

二维数组的声明方式：

数据类型　数组名[常量表达式][常量表达式]；

示例：

int a[2][3];            //定义一个2*3的二维int型数组

float f[3][4];        //定义一个3*4的二维float型数组

## 2.3 二维数组的存储方式

​        二维数组常常被称为矩阵（matrix）。把矩阵想成行(row)和列(column)的排列方式，更有助于形象化地理解二维数组地逻辑结构。

 

​        虽然二维数组在概念上可以理解是二维的，其下标在两个方向上变化，有行和列的说法。但是内存却是连续编址的，按一维线性排列的。如何在一维的存储器中存放二维数组？

存储形式：二维数组在内存中是按行的顺序存放的，即先存放第一行的元素，再存放第二行的元素,……。 

## 2.4 深入理解多维数组（二维数组）

​        在C语言中我们可以将二维数组视为一种特殊的一维数组，它的元素又是一个一维数组。例如，上图的二维数组 int a[3][4]。可以理解成由三个元素a[0]，a[1]，a[2]组成的数组，每个元素a[i]是包含四个元素的一维数组：

​        因此在C语言中的多维数组其实就是**元素为数组的数组**。n 维数组的元素是 n-1 维数组。例如，二维数组的每个元素都是一维数组，一维数组的元素当然就不是数组了。

示例：char screen[10][40][80];      // 一个三维数组

​        数组 screen 包含 10 个元素，从 screen[0] 到 screen[9]。每个元素又是一个二维数组，它有 40 个元素，这 40 个元素均是一维数组，然后每个一维数组内都有 80 个字符。整体来说，screen 数组有 32000（10×40×80）个 char 类型元素。

## 2.5 二维数组元素的引用及初始化

### 2.5.1二维数组元素的引用

数组名[行下标][列下标]

例如：ary[1][3] = 12;

### 2.5.2 分行初始化

分行给二维数组赋值。例如：

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

每行的元素使用花括号分隔开，中间用逗号分隔开，如果有未写的则默认为0。

### 2.5.3 线性初始化

​        把所有的元素都写在一个花括号内，这样会按照数组在内存中的存储顺序给二维数组赋值。例如：

int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

类似于一维数组，如果有未写的则默认为0。

### 2.5.4 全部元素初始化

​        可以提供全部元素的初值，这样常量表达式1（即第一个下标）可以缺省不写，系统会根据输入的多少来计算行数。但常量表达式2（即第二个下标）不可缺省。例如：

int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};

则系统自动计算出这个二维数组是a[3][4]。

注意：第一维的长度可以省略，但是第二维长度不能省，例如：

int a[3][]={1,2,3,4,5,6,7,8,9,10,11,12};

编译程序时，会有语法错误

## 2.6 二维数组程序实例

**示例：**自定义一个3*4的矩阵，输出矩阵中值最大的元素，并输出其数组下标

```C
#include <stdio.h>
#define row 3
#define col 4

int main(){
    int arr[row][col] = {1,4,7,2,5,8,3,6,9,11,10,0};
    int nMax = arr[0][0];
    int x, y;
    for(int i=0; i<row;i++){
        for(int j=0; j<col; j++){
            if(nMax <= arr[i][j]){
                nMax = arr[i][j];
                x = i;
                y = j;
            }
        }
    }
    printf("最大值为: arr[%d][%d] = %d\n", x, y, nMax);

    return 0;
}
```

练习：打印杨辉三角型前10行

杨辉三角型：杨辉三角型是形如以下矩阵的三角形：

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

 #include <stdio.h>
  int main(){
      int i,j,k;
      int a[10][10]={{1},{1,1}};//定义一个数组
      for(i=2;i<10;i++){
          for(j=0;j<=i;j++){ //求第三行开始后的除第一个元素外的数
              a[i][j]=a[i-1][j-1]+a[i-1][j]; //公式
             }
      }
      for(int i=0;i<10;i++){  //令俩个边的数为1
         a[i][i]=1;
          a[i][0]=1;
  }
      for(i=0;i<=9;i++){
          for(j=0;j<9-i;j++){
             printf("  ");//输出空格
           }
      for(k=0;k<=i;k++){
         printf("%3d ",a[i][k]);//输出数字
      }
       printf("\n");
  }
          printf("\n");
     return 0;
 }