java动态数组的实现的_Java实现数据结构之【动态数组】

数组

数组是学习编程语言时较先接触到的一种数据结构，本章基于Java的静态数组实现动态数组，并进行简单的复杂度分析

public class Array{private intsize;privateObject[] data;public Array(intcapacity) {

size= 0;

data= newObject[capacity];

}publicArray() {this(10);

}public intgetSize() {returnsize;

}public intgetCapacity() {returndata.length;

}public booleanisEmpty() {return size == 0;

}public voidaddLast(E e) {

add(size, e);

}public voidaddFirst(E e) {

add(0, e);

}public void add(intindex, E e) {if (index < 0 || index >size)throw new IllegalArgumentException("Add failed,index need >=0 and <=size");if (size ==data.length) {

resize(2 *data.length);

}for (int i = size - 1; i >= index; i--) {

data[i+ 1] =data[i];

}

data[index]=e;

size++;

}private void resize(intnewCapacity) {

Object[] newData= newObject[newCapacity];for (int i = 0; i < size; i++)

newData[i]=data[i];

data=newData;

}public Object get(intindex) {if (index < 0 || index >=size)throw new IllegalArgumentException("Get failed,index is illegal");returndata[index];

}public voidremoveElement(E e) {int index =find(e);if (index != -1)

remove(index);

}

@SuppressWarnings("unchecked")public E remove(intindex) {if (index < 0 || index >=size)throw new IllegalArgumentException("Remove failed,index is illegal");if (size == data.length / 4 && data.length / 2 != 0) {

resize(data.length/ 2);

}

Object temp=data[index];for (int i = index + 1; i < size; i++) {

data[i- 1] =data[i];

}

size--;

data[size]= null;return(E) temp;

}publicE removeFirst() {return remove(0);

}publicE removeLast() {return remove(size - 1);

}public booleancontains(E e) {for (int i = 0; i < size; i++) {if(data[i].equals(e))return true;

}return false;

}public intfind(E e) {for (int i = 0; i < size; i++) {if(data[i].equals(e))returni;

}return -1;

}

@OverridepublicString toString() {

StringBuilder res= newStringBuilder();

res.append(String.format("Array: size = %d , capacity = %dn", size, data.length));

res.append("[");for (int i = 0; i < size; i++) {

res.append(data[i]);if (i != size - 1)

res.append(", ");

}

res.append("]");returnres.toString();

}

}

简单时间复杂度分析

增：

add(e)   O(n)

addLast(e)   O(1)

addFirst(index,e)   O(n)

取最坏的情况所以增的时间复杂度是 O(n)

删：

删除与增加同理同是 O(n)

改：

set(index,e)

已知索引的情况下是O(1)，未知索引的情况下是O(n)

查：

get(index)   O(1)

contains(e)   O(n)

find(e)   O(n)

已知索引的情况下是O(1)，未知索引的情况下是O(n)

均摊复杂度分析

addLast：O(1)

当数组增加元素达到一定数量时，会调用resize方法进行扩容操作，例如：

一个容量为8的数组，当addLast调用9次时，会调用resize方法进行扩容操作，显然并不是每次addLast都会调用resize，所以说9次addLast操作会触发一次resize(给容量为8的数组扩容时，会有8次元素存入新数组的操作)，总共进行了17 (9次addLast加上扩容的8次元素存入新数组的操作) 次基本操作

平均每次addLast操作，进行2 (17÷9≈2) 次基本操作

也就是说，当数组容量为n时，n+1次addLast操作会调用一次resize操作，总共2n+1次基本操作

平均每次addLast操作，进行2次基本操作

所以addLast的时间复杂度可以算是O(1)的，也就是说在均摊计算中，比计算最坏的情况有意义

removeLast：与addLast同理

复杂度的震荡

当同时思考addLast和removeLast操作的时候：

假如调用addLast触发resize扩容后调用removeLast显然也会调用resize进行缩容，这个操作如果反复执行就会导致复杂度的震荡，所以代码中removeLast方法中

if (size == data.length / 4 && data.length / 2 != 0) {

resize(data.length/ 2);

}

并没有像addLast中那样直接让data.length/2，而是当数组内的元素等于四分之一容量的时候，才会执行缩容的操作，就可以解决复杂度的震荡