数据结构之数组

迈不过友情╰ 2022-02-05 05:11 220阅读 0赞

数据结构数组的学习和自己实现一个数组：

## 简介 ##

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

### 线性表 ###

零个或多个数据元素的有限序列。每个线性表上的数据最多只有前和后两个方向。其实除了数组，链表、队列、栈等也是线性表结构。

![20190502212724.png][]

它相对立的概念是非线性表，比如二叉树、堆、图等。之所以叫非线性，是因为，在非线性表中，数据之间并不是简单的前后关系。

![20190502212847.png][]

连续的内存空间和相同类型的数据:这两个限制也让数组的很多操作变得非常低效，比如要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据搬移工作。但是数组的随机访问效率确实十分的高。

### 案例 ###

拿一个长度为 10 的 int 类型的数组 int\[\] a = new int\[10\] 来举例

![20190502213326.png][]

计算机给数组 a\[10\]，分配了一块连续内存空间 1000～1039，其中，内存块的首地址为 base\_address = 1000。当我们要随机访问一个地址的时候，，它会首先通过下面的寻址公式，计算出该元素存储的内存地址：

> a\[i\]\_address = base\_address + i \* data\_type\_size

![E6_95_B0_E7_BB_84O1_E6_B7_BB_E5_8A_A0.gif][]

数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)。

数组的插入和删除都十分的低效。

## 插入 ##

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

![E6_95_B0_E7_BB_84_E4_B8_AD_E6_8F_92_E5_85_A5_E6_95_B0_E6_8D_AE.gif][]

如果在数组的末尾插入元素，那就不需要移动数据了，这时的时间复杂度为 O(1)。

![E6_95_B0_E7_BB_84_E6_9C_AB_E5_B0_BE_E6_8F_92_E5_85_A5_E6_95_B0_E6_8D_AE.gif][]

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

如果数组中的数据是有序的，我们在某个位置插入一个新的元素时，就必须按照刚才的方法搬移 k 之后的数据。但是，如果数组中存储的数据并没有任何规律，数组只是被当作一个存储数据的集 合。在这种情况下，如果要将某个数组插入到第 k 个位置，为了避免大规模的数据搬移，我们还有 一个简单的办法就是，直接将第 k 位的数据搬移到数组元素的最后，把新的元素直接放入第 k 个位 置。

![E5_BF_AB_E6_8E_92_E6_80_9D_E6_83_B3.gif][]

在特定场景下，在第 k 个位置插入一个元素的时间复杂度就会降为 O(1)。这个 处理思想在快排中会用。

## 删除 ##

插入数据类似，我们要删除第 k 个位置的数据，为了内存的连续性，也需要搬移数据，不然中间就会出现空洞，内存就不连续了。在某些特殊场景下，我们并不一定非得追求数组中数据的连续性。如果我们将多次删除操作集中在一起执行，这种就类似于Java虚拟中的标记清除。

![E6_A0_87_E8_AE_B0_E6_B8_85_E9_99_A4.gif][]

当数组没有更多空间存储数据时，我们再触发执行一次真正的删除操作，这样就大大减少了删除操作导致的数据搬移。

## 容器 ##

ArrayList 最大的优势就是可以将很多数组操作的细节封装起来。比如前面提到的数组 插入、删除数据时需要搬移其他数据等。另外，它还有一个优势，就是支持动态扩容。  
数组本身在定义的时候需要预先指定大小，因为需要分配连续的内存空间。如果我们申请了大小为 10 的数组，当第 11 个数据需要存储到数组中时，我们就需要重新分配一块更大的空间，将原来的 数据复制过去，然后再将新的数据插入。  
如果使用 ArrayList，我们就完全不需要关心底层的扩容逻辑，ArrayList 已经帮我们实现好了。每次 存储空间不够的时候，它都会将空间自动扩容为 1.5 倍大小。  
不过，这里需要注意一点，因为扩容操作涉及内存申请和数据搬移，是比较耗时的。所以，如果事 先能确定需要存储的数据大小，最好在创建 ArrayList 的时候事先指定数据大小。  
比如我们要从数据库中取出 10000 条数据放入 ArrayList。我们看下面这几行代码，你会发现，相比 之下，事先指定数据大小可以省掉很多次内存申请和数据搬移操作。

Java ArrayList 无法存储基本类型，比如 int、long，需要封装为 Integer、Long 类，而 Autoboxing、Unboxing 则有一定的性能消耗，所以如果特别关注性能，或者希望使用基本类型，就可以选用数组。

如果数据大小事先已知，并且对数据的操作非常简单，用不到 ArrayList 提供的大部分方法，也可 以直接使用数组。

当要表示多维数组时，用数组往往会更加直观。比如 Object\[\]\[\] array；而用容器的话则需要这样定义：

ArrayList <ArrayList >array。

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

## 小结 ##

从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。前面也讲到，如果用 a 来表示数组的首地址，a\[0\] 就是偏移为 0 的位置，也就是首地址，a\[k\] 就表示偏移 k 个 type\_size 的位置，所以计算 a\[k\] 的内存地址只需要用这个公式：

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 </pre></td> 
 <td><pre>a[k]_address = base_address + k * type_size </pre></td> 
 </tr> 
 </tbody> 
</table>

但是，如果数组从 1 开始计数，那我们计算数组元素 a\[k\] 的内存地址就会变为：

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 </pre></td> 
 <td><pre>a[k]_address = base_address + (k-1)*type_siz </pre></td> 
 </tr> 
 </tbody> 
</table>

从 1 开始编号，每次随机访问数组元素都多了一次减法运算，对于 CPU 来说，就是多了一次减法指令。

数组作为非常基础的数据结构，通过下标随机访问数组元素又是其非常基础的编程操作，效率的优化就要尽可能做到极致。所以为了减少一次减法操作，数组选择了从0开始编号，而不是从1开始。

## 实现 ##

<table> 
 <tbody> 
 <tr> 
 <td><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 </pre></td> 
 <td><pre>public class Array&lt;E&gt; {
 private E[] data; private int size; // 构造函数，传入数组的容量capacity构造Array public Array(int capacity){
 data = (E[])new Object[capacity]; size = 0; } // 无参数的构造函数，默认数组的容量capacity=10 public Array(){
 this(10); } // 获取数组的容量 public int getCapacity(){
 return data.length; } // 获取数组中的元素个数 public int getSize(){
 return size; } // 返回数组是否为空 public boolean isEmpty(){
 return size == 0; } // 在index索引的位置插入一个新元素e public void add(int index, E e){
 if(index &lt; 0 || index &gt; size) throw new IllegalArgumentException("Add failed. Require index &gt;= 0 and index &lt;= size."); if(size == data.length) resize(2 * data.length); for(int i = size - 1; i &gt;= index ; i --) data[i + 1] = data[i]; data[index] = e; size ++; } // 向所有元素后添加一个新元素 public void addLast(E e){
 add(size, e); } // 在所有元素前添加一个新元素 public void addFirst(E e){
 add(0, e); } // 获取index索引位置的元素 public E get(int index){
 if(index &lt; 0 || index &gt;= size) throw new IllegalArgumentException("Get failed. Index is illegal."); return data[index]; } // 修改index索引位置的元素为e public void set(int index, E e){
 if(index &lt; 0 || index &gt;= size) throw new IllegalArgumentException("Set failed. Index is illegal."); data[index] = e; } // 查找数组中是否有元素e public boolean contains(E e){
 for(int i = 0 ; i &lt; size ; i ++){
 if(data[i].equals(e)) return true; } return false; } // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1 public int find(E e){
 for(int i = 0 ; i &lt; size ; i ++){
 if(data[i].equals(e)) return i; } return -1; } // 从数组中删除index位置的元素, 返回删除的元素 public E remove(int index){
 if(index &lt; 0 || index &gt;= size) throw new IllegalArgumentException("Remove failed. Index is illegal."); E ret = data[index]; for(int i = index + 1 ; i &lt; size ; i ++) data[i - 1] = data[i]; size --; data[size] = null; // loitering objects != memory leak if(size == data.length / 4 &amp;&amp; data.length / 2 != 0) resize(data.length / 2); return ret; } // 从数组中删除第一个元素, 返回删除的元素 public E removeFirst(){
 return remove(0); } // 从数组中删除最后一个元素, 返回删除的元素 public E removeLast(){
 return remove(size - 1); } // 从数组中删除元素e public void removeElement(E e){
 int index = find(e); if(index != -1) remove(index); } @Override public String toString(){
 StringBuilder res = new StringBuilder(); res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length)); res.append('['); for(int i = 0 ; i &lt; size ; i ++){
 res.append(data[i]); if(i != size - 1) res.append(", "); } res.append(']'); return res.toString(); } // 将数组空间的容量变成newCapacity大小 private void resize(int newCapacity){
 E[] newData = (E[])new Object[newCapacity]; for(int i = 0 ; i &lt; size ; i ++) newData[i] = data[i]; data = newData; } } </pre></td> 
 </tr> 
 </tbody> 
</table>

### 测试 ###

![20190502233933.png][]

## 参考资料 ##

《玩转数据结构》

《数据结构与算法之美》

[20190502212724.png]: /images/20220205/08c2779bbcf74eaea20928fa87bd6553.png
[20190502212847.png]: /images/20220205/dcc9094aef294ec1a0c33f34a9045561.png
[20190502213326.png]: /images/20220205/42dc2b96e9d14639b33d672276ac70e6.png
[E6_95_B0_E7_BB_84O1_E6_B7_BB_E5_8A_A0.gif]: /images/20220205/fb1665a0a7464f8aa443dd74af29aa3c.png
[E6_95_B0_E7_BB_84_E4_B8_AD_E6_8F_92_E5_85_A5_E6_95_B0_E6_8D_AE.gif]: /images/20220205/bbe91c56300a44fcafb4046f9ff6f3c1.png
[E6_95_B0_E7_BB_84_E6_9C_AB_E5_B0_BE_E6_8F_92_E5_85_A5_E6_95_B0_E6_8D_AE.gif]: /images/20220205/08e04fbf22fe49b9a46b20fcfb7439f1.png
[E5_BF_AB_E6_8E_92_E6_80_9D_E6_83_B3.gif]: /images/20220205/86a8af649e4d487ea0336c322c313957.png
[E6_A0_87_E8_AE_B0_E6_B8_85_E9_99_A4.gif]: /images/20220205/bc5b0e900c684b22bbc6eca81690e110.png
[20190502233933.png]: /images/20220205/0ef6d0299da74c60bd7ff1e02510a4ea.png