Java数据结构—动态数组和时间复杂度分析

一、数组基础

 

1.1 定义

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

1.2 创建流程

当我们在 java 中当创建一个数组时，会在内存中划分出一块 连续的内存，当有数据进入的时候会将数据 按顺序的存储在这块连续的内存中。当需要读取数组中的数据时，需要提供数组中的 索引，然后数组根据索引将内存中的数据取出来，返回给读取程序。

把数据码成一排进行存放：

所有的数据结构都支持几个基本操作：读取、插入、删除数组索引可以有语意，也可以没有语意，比如说 student[2]，就代表是这个数组中的第三个学生。

因为数组在存储数据时是按顺序存储的，存储数据的内存也是连续的，所以数组最大的优点就是能够 快速查询，寻址读取数据比较容易，但是插入和删除就比较困难。

为什么数组最大的优点就是能够 快速查询。因为当我们在读取数据时，只需要告诉数组获取数据的索引位置就可以了，数组就会把对应位置的数据，读取出来

插入和 删除比较困难是因为这些存储数据的内存是连续的，数组大小固定，插入和删除都需要移动元素

例如：一个数组中编号 0>1>2>3>4这五个内存地址中都存了数组的数据，但现在你需要往4中插入一个数据，那就代表着从4开始，后面的所有内存中的数据都要往后移一个位置。

二、编写我们自己的数组类

 

我们知道想要维护某一个数据，我们需要对这个数据有这最基本的 增、删、改、查，这几个基本功能，所以我们自己手动编写的数组类，也是需要有用这几个最基本的功能，虽然不会像 List、Map这些类，那么强大，但是对于我们普通的开发来说，基本是可以满足，下图所示就是我们一个基本的数组类，那么我们是如何对数组进行改造，来编写一个属于我们自己的数组类的呢，这里我们以 增加和删除做重点讲解，本文中的所有源码会在最后贴出来，请往下看。

从上图中我们可以得知，我们创建数组类的时候，需要三个元素 data、size、capacity，而我们所需要使用的数组，肯定是要能够支持 多种数据类型，而不是单一的数据结构，因此，我们可以在设计类的时候，是需要加上泛型支持，让我们的数据结构可以支持放置 任何数据类型。

data：需要传递的数据size：元素中的个数capacity：数组的初始容量

注意：我们上面所说的放置 任何数据类型，只能是类对象，不可以是基本数据类型，但是我们每个基本数据类型都有对应的包装类，所以我们的基本类型也是可以使用的，不过只是使用的是它的包装类

因此，我们在设计我们的数组类的时候，我们可以这么设计

1. /** 
2.  * @program:  
3.  * @ClassName ArrayPlus 
4.  * @description: 
5.  * @author: lyy 
6.  * @create: 2019-11-18 22:27 
7.  * @Version 1.0 
8.  **/ 
9. public class ArrayPlus<E> { 
10.  
11.     private E[] data; 
12.     private int size; 
13.  
14.     //构造函数，传入数组的容量capacity 构造array 
15.     public ArrayPlus(int capacity){ 
16.         data = (E[])new Object[capacity]; 
17.         size = 0; 
18.     } 
19.     //无参数的构造函数，传入数组的容量capacity=10 
20.     public ArrayPlus(){ 
21.         this(10); 
22.     } 
23.  
24.     //获取元素中的个数 
25.     public int getSize(){ 
26.         return size; 
27.     } 
28.  
29.     //获取数组的容量 
30.     public int getCapacity(){ 
31.         return data.length; 
32.     } 
33.  
34.     //返回数组是否为空 
35.     public boolean isEmpty(){ 
36.         return size == 0; 
37.     } 
38.  
39.     @Override 
40.     public String toString(){ 
41.         StringBuffer res = new StringBuffer(); 
42.         res.append(String.format("Array：Size = %d，capacity = %d\n",size,data.length)); 
43.         res.append("["); 
44.         for (int i = 0; i < size; i++) { 
45.             res.append(data[i]); 
46.             if(i != size - 1) 
47.                 res.append("，"); 
48.         } 
49.         res.append("]"); 
50.         return res.toString(); 
51.     } 
52.  
53. } 

2.1 数组添加元素

在数组中是如何添加数据的呢，首先我们需要创建一个 拥有初始容量的数组，当我们创建完成之后，size是指向第一个元素的，也就是 index=0的地方，当我们添加第一个数据后 也就是 data[0]=12后，我们的元素中的个数 size，需要往后挪一位的，也就是 size++的操作，每当我们操作一位，就需要将上面的操作重复执行，直到最后一个元素添加到我们的数组中。

如下图所示：

知道了怎么操作，但是我们要如果通过代码来完成呢?

首先我们要清楚在添加的时候， 在哪里?添加什么数据?，在哪里：我们要在数据的什么地方进行添加，也就是要添加到数组中的哪个下标—— index的地方，知道了在下标，我们只需要将添加的数据，添加到数组中为 index 的地方即可，除此之外，我们只需要对添加时，做一些基本的判断就可以了，代码如下：

1. //在所有元素后添加一个新元素 
2.   public void addLast(E e){ 
3.       add(size,e); 
4.   } 
5.  
6.   //想所有元素前添加一个新元素 
7.   public void addFirst(E e){ 
8.       add(0,e); 
9.   } 
10.  
11.   //在第Index个位置插入一个新元素e 
12.   public void add(int index,E e){ 
13.       if(size == data.length) 
14.           throw new IllegalArgumentException("Add failed . Array is full."); 
15.  
16.       if(index < 0 || index > size) 
17.           throw new IllegalArgumentException("Add failed . Require index < 0 || index > size."); 
18.  
19.       for (int i = size - 1; i >= index ; i--) 
20.           data[i+1] = data[i]; 
21.  
22.       data[index]  = e; 
23.       size++; 
24.   } 

测试代码：

1. public class Main2 { 
2.  
3.     public static void main(String[] args) { 
4.         ArrayPlus<Integer> arr = new ArrayPlus<>(); 
5.         for (int i = 12; i < 16; i++) 
6.             arr.addLast(i); 
7.         System.out.println(arr); 
8.     } 
9. } 

返回结果：

1. Array：Size = 4，capacity = 10 
2. [12，13，14，15] 

在数组中是如何执行插入呢?如下图所示：

测试代码：

1. public static void main(String[] args) { 
2.  
3.        ArrayPlus<Integer> arr = new ArrayPlus<>(); 
4.        for (int i = 12; i < 16; i++) 
5.            arr.addLast(i); 
6.        System.out.println(arr); 
7.  
8.        arr.add(1,100); 
9.        System.out.println(arr); 
10.  
11.  
12.    } 

返回结果：

1. Array：Size = 4，capacity = 10 
2. [12，13，14，15] 
3. Array：Size = 5，capacity = 10 
4. [12，100，13，14，15] 

2.2 数组删除元素

如果我们想要删除 索引为1的元素，是怎样操作的呢，首先我们需要先将 索引为2的数据，覆盖到 索引为1的元素上，再将 索引为3的数据放到 索引为2上，依次循环操作，直到最后一位元素，我们在将最后一位元素的数据设置为 null，这样垃圾回收机制就会自动帮我们清除这个元素。整个过程就完成了删除元素的功能，具体流程如下图所示：

实现代码：

1. //查找数组中元素e所在的索引，如果不存在元素e，则返回-1 
2.     public int find(E e){ 
3.         for (int i = 0; i < size; i++) { 
4.             if(data[i].equals(e)) 
5.                 return i; 
6.         } 
7.         return -1; 
8.     } 
9.  
10.  //从数组中删除index位置的元素，返回删除的元素 
11.     public E remove(int index){ 
12.         if(index < 0 || index >= size) 
13.             throw new IllegalArgumentException("remove failed . Index is illegal."); 
14.  
15.         E ret = data[index]; 
16.         for (int i = index+1 ; i < size; i++) 
17.                 data[i - 1] = data[i]; 
18.  
19.         size--; 
20.         // loitering objects != memory leak 
21.         data[size] = null;//如果一旦使用新的元素，添加新的对象就会覆盖掉 
22.         return ret; 
23.     } 
24.  
25.     //从数组中删除第一个位置的元素，返回删除的元素 
26.     public E removeFirst(){ 
27.         return remove(0); 
28.     } 
29.  
30.     //从数组中删除最后一个位置的元素，返回删除的元素 
31.     public E removeLast(){ 
32.         return remove(size-1); 
33.     } 
34.  
35.     //从数组中删除元素e 
36.     public void removeElement(E e){ 
37.         int index = find(e); 
38.         if(index != -1) 
39.             remove(index); 
40.  
41.     } 

测试：

1. import com.bj.array.ArrayPlus; 
2.  
3. public class Main2 { 
4.  
5.     public static void main(String[] args) { 
6.  
7.         ArrayPlus<Integer> arr = new ArrayPlus<>(); 
8.         for (int i = 12; i < 16; i++) 
9.             arr.addLast(i); 
10.         System.out.println(arr); 
11.  
12.         arr.add(1,100); 
13.         System.out.println(arr); 
14.  
15.         arr.remove(1); 
16.         System.out.println(arr); 
17.  
18.  
19.     } 
20.  
21. } 

返回示例：

1. Array：Size = 4，capacity = 10 
2. [12，13，14，15] 
3. Array：Size = 5，capacity = 10 
4. [12，100，13，14，15] 
5. Array：Size = 4，capacity = 10 
6. [12，13，14，15] 

我们看到结果已经把索引为1的删除了，到这里我们已经完成了一大半了，还有一小点也是最重要的，就是当我们添加数据超过了我们的初始容量大小的时候，就会报错，初始容量，无法添加超过的数据，那么我们应该怎么操作呢?其实很简单，我们只需要给我们数组类，添加一个扩容的方法即可，当我们元素的个数等于数组长度的时候，我们就进行扩容，我们称之为 动态数组。

2.3 动态数组

前边我们讲过的用new给基本类型和对象在运行时分配内存，但它们的已经在编译时就已经确定下来，因为我们为之申请内存的数据类型在程序里有明确的定义，有明确的单位长度。但是，总有些时候，必须要等到程序运行时才能确定需要申请多少内存，甚至还需要根据程序的运行情况追加申请更多的内存。从某种意义上讲，这样的内存管理才是真正的动态。下面，我将带大家编写一个程序为一个整数型数组分配内存，实现动态数组。当你们看到下面这个图的时候，有没有想到什么，没错，有点像C++里面的指针

实现代码：

1. //在第Index个位置插入一个新元素e 
2.    public void add(int index,E e){ 
3.  
4.        if(index < 0 || index > size) 
5.            throw new IllegalArgumentException("Add failed . Require index < 0 || index > size."); 
6.  
7.        if(size == data.length) 
8.            resize(2 * data.length); 
9.  
10.  
11.        for (int i = size - 1; i >= index ; i--) 
12.            data[i+1] = data[i]; 
13.  
14.        data[index]  = e; 
15.        size++; 
16.    } 
17.  
18.    private void resize(int newCapacity) { 
19.        E[] newData = (E[])new Object[newCapacity]; 
20.        for (int i = 0; i < size; i++) 
21.            newData[i] = data[i]; 
22.        data = newData; 
23.    } 

动态数组测试：

1. import com.bj.array.ArrayPlus; 
2.  
3. public class Main2 { 
4.  
5.     public static void main(String[] args) { 
6.         ArrayPlus<Integer> arr = new ArrayPlus<>(); 
7.         for (int i = 0; i < 10; i++) 
8.             arr.addLast(i); 
9.         System.out.println(arr); 
10.  
11.         arr.add(1,100); 
12.         System.out.println(arr); 
13.  
14.         for (int i = 0; i < 6; i++) 
15.             arr.remove(i); 
16.  
17.         arr.removeLast(); 
18.         System.out.println(arr); 
19.     } 
20. } 

测试结果：

1. Array：Size = 10，capacity = 10 
2. [0，1，2，3，4，5，6，7，8，9] 
3. Array：Size = 11，capacity = 20 
4. [0，100，1，2，3，4，5，6，7，8，9] 
5. Array：Size = 4，capacity = 10 
6. [100，2，4，6] 

从结果中我们可以看到，当我们数组元素超过初始容量大小时，自动扩容到初始容量的 两倍也就是20，当我们数组长度小于1/4的时候，为什么是1/4的时候而不是1/2的时候呢，下面我们会做详细介绍。当我们数组长度小于1/4的时候，会自动缩回到初始10的容量，不会去占据大量的内存空间。

三、时间复杂度分析

 

3.1 基础

五种常见的时间复杂度 1) O(1)：常数复杂度, 最快的算法，数组的存取是O(1) 1) O(n)：线性复杂度, 例如：数组, 以遍历的方式在其中查找元素 1) O(logN)：对数复杂度 1) O(nlogn)：求两个数组的交集, 其中一个是有序数组，A数组每一个元素都要在B数组中进行查找操作，每次查找如果使用二分法则复杂度是 logN 1) O(n2)：平方复杂度，求两个无序数组的交集

在这里，大O描述的是算法的运行时间和输入数据之间的关系

3.2 举例说明

大家可以看下面一个例子

1. public static int sum(int[] nums){ 
2.   int sum = 0; 
3.   for(int num: nums) sum += num; 
4.   return sum; 
5. } 

• 这个算法是 O(n) 复杂度的，其中 n是nums中的元素个数，算法和n呈线性关系
• 为什么说他是 O(n)的时间复杂度呢，因为这个算法运行的时间的多少是和 nums中元素的个数成线性关系的，那么这个线性关系，表现在我们的 n 是一次方，它不是 O(n) 方的，也不是 O(n) 的立方，n 对应的是一次方。
• 我们忽略常数，实际时间是：T=c1*n+c2c1：我们要把这个数据从 nums数组中取出来，其次我们还要把 sum这个数取出来，然后 num这个数和 sum相加，最终呢我们要这个结果扔回给 sum中c2：开始开辟了一个Int型的空间，我们把它叫 sum ，要把 0 初始化赋值给sum，在最终呢我们还要把这个 sum 给 return 回去

一方面把 c1 和 c2 具体分析出来是不大必要的，另一方面也是不太可能的，为什么说不可能呢?如果说把 num 从 nums 中取出来，基于 不同的语言，基于 不同的实现，它实际运行的 时间是不等的，就算转换成机器码，它对应的机器码的指令数也有可能是不同的，就算是指令数是相同的，同样的一个指令，在我们 cpu 的底层，你使用的 cpu 不同，很有可能，执行的操作也是不同的，所以在实际上我们可能说出 c1 是几条指令，但是却很难说出 c1 到底是多少，c2也是同理，正因为如此，我们在进行时间复杂度时，是忽略这些常数的。

忽略这些常数就意味着什么，就意味着这些 t=2*n+2和t=2000*n+10000算法这些都是 O(n) 的算法，见下面列表：换句话说他们都是线性数据的算法，也就是说我们这个算法消耗的时间是和我们输入数据的规模成一个线性相关的， t=1*n*n+0也线性算法是和我们成平方关系的 ，他的性能比上面的差，因为他是 O(n^2)的

O(n)和O(n^2)并不代表说 O(n)的算法快于 O(n^2)的算法，我们要看 n 的常数，比如 n=3000的时候，或者 n>3000的时候， O(n^2)消耗的时间是远远大于 O(n)的，n越大 O(n)远远快于 O(n^2)O：描述的是一个算法，也就是说渐进时间复杂度当高阶项和低阶项同时出现的时候，低阶项会被忽略，比如说：T=2*n*n+300n+10当中 2*n*n，是 O(n^2)级别的算法，属于高阶项， 300n是 O(n)的算法低阶项，当n无穷大的时候，低阶项起的作用很小。

3.3 分析动态数组的时间复杂度

3.3.1 添加操作

添加操作 总体来说属于 O(n) 级别的复杂度，如下列表

在程序设计中，我们要采用最严谨的设计，需要考虑到最坏的情况，所以我们说添加操作时属于 O(n)级别的复杂度，是因为我们在 addLast的时候，有可能会进行 resize的操作，我们从最坏的情况分析是对的，但是 addLast不可能每次都是进行 resize操作，比如 size 有十个，我们要添加十个元素后才会触发一个 resize,我们要在添加十个元素才会触发一个 resize，因此我们使用最坏情况进行分析的是不合理的，那么分析 addLast时间复杂度呢，请看下面小节。

3.3.2 resize的复杂度分析

总共进行了17次基本操作：9次添加操作8次元素转移操作

• 9次addLast操作，触发resize，总共进行了17次基本操作，平均每次addLast操作，进行了2次基本操作
• 假设 capacity = n，n+1 次addLast，触发resize，总共进行了2n+1次基本操作，平均，每次addLast操作，进行了2次基本操作
• 这样均摊计算，时间复杂度是O(1)的，在这个例子里，这样均摊计算，比计算最坏情况有意义
• addLast 均摊复杂度是O(1)的，同理我们看 removeLast操作，均摊复杂度也是O(1)

3.3.3 复杂度震荡

当我们数组容量满了的时候，因为是动态数组，回去自动扩容，我们又马上去remove 一个操作的时候，因为数组容量小于 初始容量的一半的时候，又会 自动 resize缩减为一半的大小，如此操作，就会一个问题，就是我们在 removeLast的时候 resize 过于着急(Eager)

解决方案：Lazy，懒散的，其实也很简单，如下图所示：

当我们的 size == capacity /4 时候，才将capacity 减半，实现方式如下：

1. //从数组中删除index位置的元素，返回删除的元素 
2.     public E remove(int index){ 
3.         if(index < 0 || index >= size) 
4.             throw new IllegalArgumentException("remove failed . Index is illegal."); 
5.  
6.         E ret = data[index]; 
7.         for (int i = index+1 ; i < size; i++) 
8.                 data[i - 1] = data[i]; 
9.  
10.         size--; 
11.         // loitering objects != memory leak 
12.         data[size] = null;//如果一旦使用新的元素，添加新的对象就会覆盖掉 
13.  
14.         if(size == data.length / 4 && data.length / 2 != 0) 
15.             resize(data.length / 2); 
16.  
17.         return ret; 
18.     } 

完整代码：

1. package com.bj.array; 
2.  
3.  
4. /** 
5.  * @program: Data-Structures 
6.  * @ClassName Array 
7.  * @description: 
8.  * @author: lyy 
9.  * @create: 2019-11-18 22:27 
10.  * @Version 1.0 
11.  **/ 
12. public class ArrayPlus<E> { 
13.  
14.     private E[] data; 
15.     private int size; 
16.  
17.     //构造函数，传入数组的容量capacity 构造array 
18.     public ArrayPlus(int capacity){ 
19.         data = (E[])new Object[capacity]; 
20.         size = 0; 
21.     } 
22.     //无参数的构造函数，传入数组的容量capacity=10 
23.     public ArrayPlus(){ 
24.         this(10); 
25.     } 
26.  
27.     //获取元素中的个数 
28.     public int getSize(){ 
29.         return size; 
30.     } 
31.  
32.     //获取数组的容量 
33.     public int getCapacity(){ 
34.         return data.length; 
35.     } 
36.  
37.     //返回数组是否为空 
38.     public boolean isEmpty(){ 
39.         return size == 0; 
40.     } 
41.  
42.     //在所有元素后添加一个新元素 
43.     public void addLast(E e){ 
44.         add(size,e); 
45.     } 
46.  
47.     //想所有元素前添加一个新元素 
48.     public void addFirst(E e){ 
49.         add(0,e); 
50.     } 
51.  
52.     //在第Index个位置插入一个新元素e 
53.     public void add(int index,E e){ 
54.  
55.         if(index < 0 || index > size) 
56.             throw new IllegalArgumentException("Add failed . Require index < 0 || index > size."); 
57.  
58.         if(size == data.length) 
59.             resize(2 * data.length); 
60.  
61.  
62.         for (int i = size - 1; i >= index ; i--) 
63.             data[i+1] = data[i]; 
64.  
65.         data[index]  = e; 
66.         size++; 
67.     } 
68.  
69.  
70.  
71.     //获取index索引位置的元素 
72.    public E get(int index){ 
73.         if(index < 0 || index >= size) 
74.             throw new IllegalArgumentException("Get failed . Index is illegal."); 
75.  
76.         return data[index]; 
77.     } 
78.  
79.     //修改index索引位置的元素为e 
80.     public void set(int index,E e){ 
81.         if(index < 0 || index >= size) 
82.             throw new IllegalArgumentException("Set failed . Index is illegal."); 
83.  
84.          data[index] = e; 
85.     } 
86.  
87.     //查找数组中是否有元素e 
88.     public boolean contains(E e){ 
89.         for (int i = 0; i < size; i++) { 
90.             if(data[i].equals(e)) 
91.                 return true; 
92.         } 
93.         return false; 
94.     } 
95.  
96.     //查找数组中元素e所在的索引，如果不存在元素e，则返回-1 
97.     public int find(E e){ 
98.         for (int i = 0; i < size; i++) { 
99.             if(data[i].equals(e)) 
100.                 return i; 
101.         } 
102.         return -1; 
103.     } 
104.  
105.     //从数组中删除index位置的元素，返回删除的元素 
106.     public E remove(int index){ 
107.         if(index < 0 || index >= size) 
108.             throw new IllegalArgumentException("remove failed . Index is illegal."); 
109.  
110.         E ret = data[index]; 
111.         for (int i = index+1 ; i < size; i++) 
112.                 data[i - 1] = data[i]; 
113.  
114.         size--; 
115.         // loitering objects != memory leak 
116.         data[size] = null;//如果一旦使用新的元素，添加新的对象就会覆盖掉 
117.  
118.         if(size == data.length / 4 && data.length / 2 != 0) 
119.             resize(data.length / 2); 
120.  
121.         return ret; 
122.     } 
123.  
124.     //从数组中删除第一个位置的元素，返回删除的元素 
125.     public E removeFirst(){ 
126.         return remove(0); 
127.     } 
128.  
129.     //从数组中删除最后一个位置的元素，返回删除的元素 
130.     public E removeLast(){ 
131.         return remove(size-1); 
132.     } 
133.  
134.     //从数组中删除元素e 
135.     //思考？如果返回是否删除成功 2、如果存在重复数据，如何删除多个 
136.     public void removeElement(E e){ 
137.         int index = find(e); 
138.         if(index != -1) 
139.             remove(index); 
140.  
141.     } 
142.  
143.     @Override 
144.     public String toString(){ 
145.         StringBuffer res = new StringBuffer(); 
146.         res.append(String.format("Array：Size = %d，capacity = %d\n",size,data.length)); 
147.         res.append("["); 
148.         for (int i = 0; i < size; i++) { 
149.             res.append(data[i]); 
150.             if(i != size - 1) 
151.                 res.append("，"); 
152.         } 
153.         res.append("]"); 
154.         return res.toString(); 
155.     } 
156.  
157.     private void resize(int newCapacity) { 
158.         E[] newData = (E[])new Object[newCapacity]; 
159.         for (int i = 0; i < size; i++) 
160.             newData[i] = data[i]; 
161.         data = newData; 
162.     } 
163.  
164. } 

有时候更"懒"，会让我们的程序更方便点，我是牧小农，大家加油!

原文地址：https://mp.weixin.qq.com/s/pXiMsaoyWEzakH_Ouifq-A