C++ 入门：一维数组基础与实战

观察上图我们可以观察到：

1. 下标是从 0 开始的
2. 数组长度是 10，最后一个数据的下标是 9
3. 数据 3 的下标是 2，数据 8 的下标是 7

3.2 通过数组下标访问元素

访问元素的方式为：数组名 [下标]

3.2.1 访问单独数据

3.2.2 访问数组当中的所有数据

求数据之和

3.2.3 给数组输入元素

#include <stdio.h>

int main() {
    int arr[5];
    int i = 0;
    for (i = 0; i < 5; i++) {
        scanf("%d", &arr[i]);
    }
    for (i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

4. 一维数组在内存当中的存储

数组的内存特性

我们知道数组的定义是相同类型元素的一个集合（例如 int 类型不能定义 float 元素）。在内存中是一段连续的空间。

意味着每个元素与每个元素之间内存是连续的。

通过程序打印数组中每个元素的地址：

#include <stdio.h>

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int i = 0;
    for (i = 0; i < 10; i++) {
        printf("&arr[%d] = %d\n", i, &arr[i]);
    }
    return 0;
}

输出结果：

&arr[0] = 844954664 &arr[1] = 844954668 &arr[2] = 844954672 &arr[3] = 844954676 &arr[4] = 844954680 &arr[5] = 844954684 &arr[6] = 844954688 &arr[7] = 844954692 &arr[8] = 844954696 &arr[9] = 844954700

观察输出结果我们发现，由于是整型数组，每个元素是 4 个字节，所以地址间隔也是 4，即是一段连续的空间。

5. sizeof 与数组

sizeof 计算数组大小

我们可以通过 sizeof(数组名) 来计算整个数组的字节大小。

#include <stdio.h>

int main() {
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    printf("%d\n", sizeof(arr));
    return 0;
}

此时输出结果是 40，表示整个数组此时所占内存空间的大小为 40 字节。

我们已知整个数组的字节大小为 40 字节，每个元素的大小为 4 个字节。此时就可以计算出数组的长度。

即如果不知道数组内元素的个数情况下，可以用

sizeof(arr) / sizeof(arr[0])

计算出数组的元素个数。

例如以下代码：

#include <stdio.h>

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

6. 一维数组习题练习

6.1 数组的逆置

把数组当中的元素进行逆置输出。

6.2 数组元素扩大 2 倍

给定指定数组，将原数组当中的每个元素扩大 2 倍，输出最后数组的元素。

6.3 二分查找

题目：给定一个升序的整型数组，在这个数组中查找到指定的值 n，找到了就打印 n 的下标，找不到就打印：'找不到'。

提示：在一个升序的数组中查找指定的数字 n，很容易想到的方法就是遍历数组，但是这种方法效率比较低。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int len = sizeof(arr) / sizeof(arr[0]);
    int left = 0;
    int right = len - 1;
    int n = 3; // 要找的数
    int mid = -1; // 定义中间值
    int e = 0; // 该值未改变表示最后没有进入 while 循环即一直没有达到 else 情况但已经 left>right
    while (left <= right) // 当 left>=right 时说明要找的数不在数组里
    {
        mid = left + (right - left) / 2; /*求中间元素的下标，使用 mid = (left + right) / 2，如果 left 和 right 值非常大时，它们的和可能会超出整型范围导致溢出。更稳妥的写法是：mid = left + (right - left) / 2;*/
        if (arr[mid] < n)
        {
            left = mid + 1;
        }
        else if (arr[mid] > n)
        {
            right = mid - 1;
        }
        else
        {
            e = 1;
            break;
        }
    }
    if (e == 1)
    {
        printf("找到了，下标是：%d\n", mid);
    }
    else
    {
        printf("没有找到\n");
    }
    return 0;
}

【拓展】因为二分查找需要数组是升序的，若数组是乱序的怎样改成升序的呢？

先用冒泡排序讲解，后面会有排序专题。

冒泡排序就是多趟比较，每一趟都从数组开头往后走：

• 拿当前数和下一个数比
• 前面比后面大，就交换
• 前面比后面小，就不动
• 每走完一趟，最大的数会沉到最后

例如有一个数组 arr[]={12, 7, 6, 9, 3}

第 1 趟

12 和 7 比 → 交换 → 7, 12, 6, 9, 3 12 和 6 比 → 交换 → 7, 6, 12, 9, 3 12 和 9 比 → 交换 → 7, 6, 9, 12, 3 12 和 3 比 → 交换 → 7, 6, 9, 3, 12 一趟走完，最大的 12 到位了。

第 2 趟

7 和 6 比 → 交换 → 6, 7, 9, 3, 12 7 和 9 比 → 不动 9 和 3 比 → 交换 → 6, 7, 3, 9, 12 二趟走完，第二大的 9 也到位了。

后面几趟同理，每趟确定一个大数的位置，直到整个数组从小到大排好。

代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
    int arr[] = {7, 12, 9, 6, 3};
    int len = sizeof(arr) / sizeof(arr[0]);
    printf("排序之前:\n");
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    printf("排序之后:\n");
    for (int i = 0; i < len - 1; i++)
    {
        int r = 0; // 假设本趟没有交换
        for (int j = 0; j < len - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int a = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = a;
                r = 1; // 发生交换
            }
        }
        if (r == 0)
        {
            break; /*如果 r=0 说明数组中数据在这一趟中没有发生调换 数组本身就是有序的就不用进行后续循环了*/
        }
    }
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}