数据结构与算法之美 | 数组（Array）

数组

定义：数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。

要点：

线性表：数据像一条线一样的结构，每个线性表上的数据只有前和后两个方向（数组、链表、队列和栈等）

非线性表结构：数据之间不是简单的前后关系（二叉树、堆、图等）
连续的内存空间
相同类型的数据

数组和链表的区别是什么？

链表适合插入、删除，时间复杂度 O(1)
数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)，排好序的数组，用二分查找，时间复杂度是 O(logn)

数组的基本操作

（一）数组插入操作

问题：假设数组的长度为 n，现在，如果我们需要将一个数据插入到数组中的第 k 个位置。为了把第 k 个位置腾出来，给新来的数据，我们需要将第 k～n 这部分的元素都顺序地往后挪一位。那插入操作的时间复杂度是多少呢？

如果在数组的末尾插入，不需要移动数据，最好时间复杂度为O(1)
如果在数组的开头插入，所有数据都需要依次往后移动一位，最坏时间复杂度为O(n)
因为我们在每个位置插入元素的概率是一样的，所以平均情况时间复杂度为 (1+2+…n)/n=O(n)

数组插入的处理技巧：

若数组有序，按照上述方法搬运新数据即可
若数据无序，如果要将某个数据插入到第 k 个位置，可将第 k 位数据移到最后再插入新元素以避免大规模搬移。

（二）数组删除操作

如果删除数组末尾的数据，则最好时间复杂度为 O(1)；
如果删除开头的数据，则最坏时间复杂度为 O(n)；
平均情况时间复杂度也为 O(n)

数组删除小技巧：

在不追求数组中数据的连续性时，可将删除操作集中在一起执行，可以提升删除效率。

假设数组a[10]中存储了 8 个元素：a，b，c，d，e，f，g，h。现在，我们要依次删除 a，b，c 三个元素。为了避免 d，e，f，g，h 这几个数据会被搬移三次，我们可以先记录下已经删除的数据。每次的删除操作并不是真正地搬移数据，只是记录数据已经被删除。当数组没有更多空间存储数据时，我们再触发执行一次真正的删除操作（JVM标记清除垃圾回收算法¹）

数组越界问题

以下是一个C语言的数组越界代码示例：

int main(int argc, char* argv[]){
    
    
    int i = 0;
    int arr[3] = {
    
    0};
    // 问题代码，应为i<3
    for(; i<=3; i++){
    
    
        arr[i] = 0;
        printf("hello world\n");
    }
    return 0;
}

这个代码会出现数组越界。在这段代码中，数组 arr 的大小为 3，而循环条件是 i<=3，因此当 i 的值为 3 时，循环会继续执行一次，此时会访问 arr[3]，arr[3]也会被定位到某块不属于数组的内存地址上，而这个地址正好是存储变量 i 的内存地址，那么 arr[3]=0 就相当于 i=0，所以就会导致代码无限循环。

在Java中，会自动进行越界检查，抛出：java.lang.ArrayIndexOutOfBoundsException

数组的容器类

容器类是指在程序设计中，用于保存和管理一组对象的类。

常见的数组容器类：

C++ 中的 std::array 和 std::vector
Java 中的 ArrayList
Python 中的 list
JavaScript 中的 Array
……

以Java中的ArrayList为例：

最大的优势是可以将很多数组操作的细节封装起来
支持动态扩容，使用者完全不需要关系底层的扩容逻辑，每次存储空间不够的时候会自动扩容为1.5倍大小
注意：需要在创建 ArrayList 的时候事先指定数据大小，因为扩容操作比较耗时

数组的适用场景：

Java ArrayList 无法存储基本类型，比如 int、long，需要封装为 Integer、Long 类，而 Autoboxing、Unboxing 则有一定的性能消耗，所以如果特别关注性能，或者希望使用基本类型，就可以选用数组。
如果数据大小事先已知，并且对数据的操作非常简单，用不到 ArrayList 提供的大部分方法，也可以直接使用数组。
当要表示多维数组时，用数组往往会更加直观。比如Object[][] array；而用容器的话则需要这样定义：ArrayList <ArrayList<objecy> > array

二者如何选择？

对于业务开发，可以直接使用容器就OK；对于底层开发工作，数组就是首选

为什么数组要从0开始编号

从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。以下是数组内存地址的不同计算公式：

// 数组从0开始编号：
// a[i]地址 = 首地址 + i * 元素大小
a[i]_address = base_address + i * data_type_size
    
// 数组从1开始编号：
a[i]_address = base_address + (i-1) * type_size

效率优化原因：从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令
历史原因：C 语言设计者用 0 开始计数数组下标，因此后续高级语言继续沿用了从0开始计数的习惯

二维数组内存寻址方法

对于 m * n 的数组，a [ i ][ j ] (i < m,j < n)的地址为：

// 首先找到第 i 行的起始位置，然后加上第 j 个元素的偏移量，就可以得到 a[i][j] 元素在内存中的地址
a[i][j]_address = base_address + ( i * n + j) * type_size

m 表示数组的行数，n 表示数组的列数，
type_size 表示数组中每个元素的大小，base_address 表示数组的起始地址。

对于 a[i][j] 这个元素，它在数组中的位置可以表示为：第 i 行，第 j 列。由于数组存储是按行存储的，所以前 i - 1 行的元素占用的内存空间已经被分配出去了，第 i 行的元素需要放在前面已经分配的空间之后。在第 i 行中，第 j 个元素的位置可以表示为：第 i 行的起始位置 + j 个元素的偏移量。

第 i 行的起始位置可以表示为：base_address + i * n * type_size，其中 i * n 表示前 i - 1 行元素占用的内存空间。
j 个元素的偏移量可以表示为：j * type_size。

小结

本文介绍了数组的定义、特点和基本操作，包括插入、删除和越界问题等。同时还讨论了数组与链表的区别以及适用场景，并解释了为什么数组从0开始编号。最后提到常见的数组容器类和二维数组内存寻址方法。

参考文献

王争. “为什么很多编程语言中数组都从0开始编号？” 极客时间. 2018

JVM标记清除算法，大多数主流虚拟机采用可达性分析算法来判断对象是否存活，在标记阶段，会遍历所有 GC ROOTS，将所有 GC ROOTS 可达的对象标记为存活。只有当标记工作完成后，清理工作才会开始。 ↩︎