数据结构与算法（三）——数组

2020年11月3日 114次阅读 来源: MrTreeson

线性表

线性表，顾名思义，是具有像线一样的性质的表，数据排成像一条线一样的结构。线性表是零个或多个数据元素的有限序列。序列，意味着线性表的元素是有顺序的，每个线性表上的数据最多只有前和后两个方向，常见的线性表有数组、链表、队列和栈等等。而和它相对立的概念是非线性表，即数据之间不是简单的前后关系，可能是一对多甚至多对多，常见的有二叉树、堆、图等。

线性表的存储结构

线性表有两种物理结构（即存储结构）：顺序存储结构和链式存储结构

  • 线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素，一般可用一维数组来实现。
  • 线性表的链式存储结构，是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的，即存储位置是任意的。此外，还需要额外的存储空间存储其直接后继或前继的存储位置。

数组

数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。正是因为数组要求必须是连续的内存空间和相同类型的数据，才使其有“随机访问”的特性。但是这些限制也让数组的很多操作变得非常低效，比如要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据搬移工作。

数组访问

数组是根据下标随机访问数组元素的，所以查找元素或访问元素的时间复杂度为O(1)。以一个int类型的数组为例，计算机给该数组分配了一块连续的内存空间，其中，内存块的首地址为base_address。

计算机会给每个内存单元分配一个地址，计算机通过地址来访问内存中的数据。当计算机需要随机访问数组中的第i个元素时，它会通过下面的寻址公式，计算出该元素存储的内存地址：

a[i]_address = base_address + i * data_type_size

其中 data_type_size 表示数组中每个元素的大小。数组中存储的是 int 类型数据，所以 data_type_size就为4个字节。

此外，要注意的是，数组是适合查找操作，但是查找的时间复杂度并不为 O(1)。即便是排好序的数组，用二分查找，时间复杂度也是 O(logn)。所以，正确的表述是，数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)。

插入

由于数组自身的限制，会导致插入、删除这两个操作比较低效，先看插入操作。

假设数组的长度为 n，现在，如果我们需要将一个数据插入到数组中的第 k 个位置。为了把第 k 个位置腾出来，给新来的数据，我们需要将第 k～n 这部分的元素都顺序地往后挪一位。

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

举个例子，假设数组a[n]中存储了如下 5 个元素：a，b，c，d，e。现在需要将元素 x 插入到第3个位置。我们需要将 a[2] 赋值为 x ，并把a[2]及其后面所有的元素都往后移动一位。最后，数组中的元素如下： a，b，x，d，e，c。
《数据结构与算法（三）——数组》

删除

跟插入数据类似，如果要删除第 k 个位置的数据，为了内存的连续性，也需要搬移数据，不然中间就会出现空洞，内存就不连续了。

  • 如果在数组的末尾删除元素，不需要移动数据，时间复杂度为 O(1)。
  • 但如果在数组的开头删除元素，所有的数据都需要依次往前移动一位，最坏时间复杂度是 O(n)。
  • 平均情况时间复杂度也为 (1+2+…n)/n=O(n)。

实际上，在某些特殊场景下，并不一定非得追求数组中数据的连续性。如果将多次删除操作集中在一起执行，删除的效率就会提高很多。比如说数组a[10] 中存储了 8 个元素：a，b，c，d，e，f，g，h。现在要依次删除 a，b，c 三个元素。

如果按照之前的做法，每删除一个元素就要搬移一遍数据，那么每个数据都会被搬移三次，这会造成不必要的性能消耗和浪费。为了避免多次搬移，可以先记录下已经删除的数据。每次的删除操作并不是真正地搬移数据，只是记录数据已经被删除。当数组没有更多空间存储数据时，我们再触发执行一次真正的删除操作，这样就大大减少了删除操作导致的数据搬移。

这种优化策略其实就是JVM标记清除垃圾回收算法的核心思想，所以学习数据结构和算法不是要去死记硬背某个数据结构或者算法，而是要学习它背后的思想和处理技巧，这些东西才是最有价值的。

数组越界问题

在下面这段代码中，定义了一个大小为3的数组，其元素为a[0]，a[1]，a[2]，而第二行代码却错误的使用了a[3]这个元素赋值，3超过了数组的下标界限，就导致了数组访问越界。

int[] a = new int[3];
a[3] = 10;

在 C 语言中，只要不是访问受限的内存，所有的内存空间都是可以自由访问的。数组越界在 C 语言中是一种未决行为，并没有规定数组访问越界时编译器应该如何处理。因为，访问数组的本质就是访问一段连续内存，只要数组通过偏移计算得到的内存地址是可用的，那么程序就可能不会报任何错误。

这种情况下，一般都会出现莫名其妙的逻辑错误，debug 的难度非常的大。而且，很多计算机病毒也正是利用到了代码中的数组越界可以访问非法地址的漏洞，来攻击系统，所以写代码的时候一定要警惕数组越界。

但是在Java中，对上面代码进行编译的时候就会做越界检查，会抛出java.lang.ArrayIndexOutOfBoundsException，不需要程序员自己进行数组越界检查，但是为了养成良好的编码习惯，应该避免出现写出数组越界这样的低级错误。

容器和数组

针对数组类型，很多语言都提供了容器类，比如 Java 中的ArrayList、C++ STL 中的 vector。在项目开发中，应该根据实际情况选择使用数组还是容器。

以Java为例，ArrayList与数组相比，有以下一些优势：

  • ArrayList可以将很多数组操作的细节封装起来，比如前面的数组插入、删除数据时需要搬移其他数据等。这些都是由ArrayList内部完成，只需调用其API的方法即可。
  • 此外，ArrayList支持动态扩容。在定义数组的时候需要指定其大小，以保证连续内存空间的分配。当数组存满时，如果想再插入数据，就需要重新定义一个数组，重新分配一个更大的空间，再把原来的数据复制过去，再进行插入操作。而如果使用 ArrayList，就完全不需要关心底层的扩容逻辑，ArrayList 已经实现好了。每次存储空间不够的时候，它都会将空间自动扩容为 1.5 倍大小。
  • 需要注意的是，因为扩容操作涉及内存申请和数据搬移，是比较耗时的。所以，如果事先能确定需要存储的数据大小，最好在创建 ArrayList 的时候事先指定数据大小。

但是，有利也有弊，与数组相比，ArrayList也有一些劣势。

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

所以，对于业务开发，直接使用容器就足够了，省时省力。耗一点点性能，完全不会影响到系统整体的性能。但如果是做一些非常底层的开发，比如开发网络框架，性能的优化需要做到极致，这个时候数组就会优于容器，成为首选。

总结

在对数组进行分析的时候，就对线性表的顺序存储结构进行了分析，其优缺点如下表所示。

优点缺点
无须为表示表中元素之间的逻辑关系而增加额外的存储空间插入和删除操作需要移动大量元素
可以快速地存取表中任意位置的元素当线性表长度变化较大时，难以确定存储空间的容量
造成存储空间的“碎片”

数组相关算法题

搜索二维矩阵

这是leetcode上的第240题，在一个二维矩阵中寻找一个目标值target，链接和题目描述如下：
https://leetcode-cn.com/problems/search-a-2d-matrix-ii/description/
《数据结构与算法（三）——数组》

首先，二维矩阵实际上就可以看作是二维数组array[i][j]，用常规的暴力循环遍历整个数组肯定能完成这个任务，但是时间复杂度为O(n*m)，效率太低了，不符合题目要求。

由于该二维数组的的行和列都是有序排列的，每行的元素从左到右升序排列，每列的元素从上到下升序排列。所以可以取左下角的元素为第一个元素开始匹配：

  • 当target==这个元素时，返回true；
  • 当target<数组的元素，就把行数-1，即往上一行找，找到则返回true；
  • 当target>数组的元素，就把列数+1，即往该行的后面找，找到则返回true；
  • 如果遍历了整个二维数组都没有找到，就返回false；
  • 在最坏的情况下，在遍历了整个二维数组后，发现没有这个target，这时候遍历的最多总次数是行数+列数，题目中的时间复杂度就是O(n+m)，因为在判断该行不符合条件时，是直接跳到上一行，最多跳n次；而发现该行可能符合条件时，就对其进行该行的遍历，最多该行的所有列即m次，所以时间复杂度为O(n+m)。

代码如下：

public static boolean Find(int target, int [][] array) {
    int rowCount = array.length;
    int colCount = array[0].length;
    int i,j;
    for(i=rowCount-1,j=0;i>=0&&j<colCount;)
    {
        if(target == array[i][j])
            return true;
        if(target < array[i][j])
        {
            i--;
            continue;
        }
        if(target > array[i][j])
        {
            j++;
            continue;
        }
    }
    return false;
}
    原文作者：MrTreeson
    原文地址: https://blog.csdn.net/MrTreeson/article/details/84582527
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞