【C语言基础学习笔记】数组

• 1. 数组的创建和初始化
• • 1.1 数组的创建
  • 1.2 数组初始化
  • 1.3 一维数组的使用
  • 1.4一维数组在内存中的存储
• 2. 二维数组的创建和初始化
• • 2.1二维数组的创建
  • 2.2 二维数组的初始化
  • 2.3 二维数组的访问
  • 2.4 二维数组的存储
• 3. 数组越界
• 4.数组作为函数的参数
• 5.数组应用
• • 5.1 三子棋
  • 5.2扫雷游戏

数组是一组相同类型元素的集合
数组创建的方式：

数组元素的类型 数组名 [数组大小]

举例：
注意：C99之前，数组的大小必须是常量，C99之后可以是变量

int arr[10]

不完全初始化：没有初始化的就被初始化成默认值(int的默认值是0)

int arr[10] = {1, 2, 3, 4};

如果数组**不初始化**，那么数组里面的就都是**随机值**;

所有的局部变量不经过初始化都是随机值，全局变量，静态变量(static)没有进行初始化就是默认值

int arr[10];

下标引用操作符：[]，例如arr[4]，arr和4是[]的操作数

#include 

int main() {
    // 写代码赋值
    int i = 0;
    int arr[100] = {0};
    int sz = sizeof (arr) / sizeof (arr[0]);
    // 赋值
    for (i = 0; i < sz; i++)
    {
        arr[i] = i + 1;
    }
    // 打印
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

%p：打印地址(16进制)

结论：

• 一维数组是连续存放的，因为一个int占4个字节，所以相邻的地址相差4个字节
• 随着下标的增长，地址从低到高变化

int arr[3][5]; // 3行5列
char arr1[5][7];

不完全初始化，没初始化的就初始化为默认值
行可以省略，列不能省略

// 先放满一行然后再放其他行
int arr[3][5] = {1, 2, 3, 4, 5, 6};

// 要求：第一行放1，2； 第二行放3，4； 第三行放5，6
int arr[3][5] = {{1, 2}, {3, 4}, {5, 6}};

int main()
{
    int arr[][5] = {{1, 2}, {3, 4}, {5, 6}};
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 5; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("n");
    }

    return 0;
}

运行结果：

也可以不把循环的行跟列写死，可以写成下面这种形式：

• 行：sizeof(arr) / sizeof(arr[0])
• 列：sizeof(arr[0]) / sizeof(arr[0][0])

int main()
{
    int arr[][5] = {{1, 2}, {3, 4}, {5, 6}};
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        for (j = 0; j < 5; j++)
        {
            printf("&arr[%d][%d] = %p n", i, j, &arr[i][j]);
        }
        printf("n");
    }

    return 0;
}

总结：

• 二维数组在内存中也是连续存放的
• 随着下标的增长，地址从低到高变化

这个自己写程序的时候要注意，编译器不一定会发现

例子：写一个冒泡排序，对数组进行排序(升序)
冒泡排序：数组中2个相邻的元素进行比较，不符合升序(降序)就进行交换
每趟确定一个，如果有10个元素，只需要9趟即可
注意：
bubble_sort()要传给他一个数组大小的，不能在bubble_sort函数里面求数组的大小，因为bubble_sort传的是数组的首地址(指针)，大小是1，不是实际的数组大小

void bubble_sort(int arr[], int sz)
{
    // 趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main()
{
    int arr[] = {1, 2, 3, 4, 9, 8, 10};
    int sz = sizeof (arr) / sizeof (arr[0]);
    bubble_sort(arr, sz);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

一般情况下，数组名表示数组的首元素地址，但是有两个例外：

1. sizeof(数组名)：数组名表示整个数组，计算的是整个数组的大小
2. &数组名，数组名不是数组首元素的地址，数组名表示整个数组，取出的是整个数组的地址

&arr、&arr + 1、&arr[0]、arr之间的区别，如下图所示

优化版的冒泡排序

void bubble_sort(int arr[], int sz)
{
    // 趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int flag = 1; // 假设已经有序
        int j = 0;
        for (j = 0; j < sz - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                flag = 0; // 进到这里就说明假设不成立
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        // 一趟过后，如果flag还是1(假设有序的情况)，就跳出循环
        if (1 == flag)
        {
            break;
        }
    }
}