最近在學資料結構，接下來一段時間我將用java來實現所學的各種資料結構，以加深自己的印象。

線性表包括順序表和連結串列，其實順序表就是動態陣列，下面我將二次封裝實現屬於自己的動態陣列。

-----------------------------------------------------------------------------------------------------------------------------------------------------

陣列類：Array

陣列名：data

陣列容量：capacity

已存放元素個數：size

方法：

①獲取陣列中元素個數（getSize

②獲取陣列容量（getCapacity）

③返回陣列是否為空（isEmpty）

④向陣列末尾新增元素（addLast）

⑤向指定索引位置新增元素（add）

⑥向所有元素前新增一個新元素（addFirst）

⑦得到指定索引位置的元素（get）

⑧修改指定索引位置的元素（set）

⑨查詢陣列中是否有指定元素（contains）

⑩查詢陣列中指定元素的索引（find）

⑪刪除指定索引位置的元素（remove）

⑫刪除陣列中第一個元素（removeFirst）

⑬刪除陣列最後一個元素（removeLast）

⑭查詢指定元素並刪除（removeElement）

⑮實現擴容和縮容（resize

當然感興趣的可以繼續新增自己想要的功能,比如刪除全部元素等等。

-----------------------------------------------------------------------------------------------------------------------------------------------

public class Array<E> {
	private E[] data;
	private int size;// 陣列中元素個數

	// 建構函式，傳入陣列容量capacity構造Array
	public Array(int capacity) {
		data = (E[]) new Object[capacity];
		size = 0;
	}

	// 無引數建構函式，預設陣列容量為10
	public Array() {
		this(10);
	}

	// 獲取陣列容量
	public int getCapacity() {
		return data.length;
	}

	// 獲取陣列中元素個數
	public int getSize() {
		return size;
	}

	// 返回陣列是否為空
	public boolean isEmpty() {
		return size == 0;
	}

	// 向陣列所有元素前新增元素
	public void addFirst(E e) {
		add(0, e);
	}

	// 向陣列末尾新增元素
	public void addLast(E e) {
		add(size, e);
	}

	// 向陣列index位置插入元素e
	public void add(int index, E e) {
		if (index < 0 || index > size)
			throw new IllegalArgumentException("操作失敗，需要滿足 index<0 || index>size");
		if (size == data.length)
			resize(data.length << 1);// 實現兩倍擴容
		// 使元素往後挪一個位置
		for (int i = size - 1; i >= index; i--)
			data[i + 1] = data[i];
		data[index] = e;
		size++;
	}

	// 得到指定索引上的陣列元素
	public E query(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("操作失敗，需要滿足 index < 0 || index >= size");
		return data[index];
	}

	// 獲得第一個元素
	public E getFirst() {
		return query(0);
	}

	// 獲得最後一個元素
	public E getLast() {
		return query(size - 1);
	}

	// 將指定索引上的元素修改成e
	public void modify(int index, E e) {
		data[index] = e;
	}

	// 查詢陣列中是否有元素e
	public boolean contains(int e) {
		for (int i = 0; i < size; i++)
			if (data[i].equals(e))
				return true;
		return false;
	}

	// 查詢陣列中指定元素的一個索引
	public int find(E e) {
		for (int i = 0; i < size; i++)
			if (data[i].equals(e))
				return i;
		return -1;
	}

	// 刪除指定索引上的元素，返回刪除元素
	public E remove(int index) {
		if (index < 0 || index >= size)
			throw new IllegalArgumentException("操作失敗，需要滿足 index < 0 || index >= size");
		E temp = data[index];
		for (int i = index + 1; i < size; i++)
			data[i - 1] = data[i];
		size--;
		data[size] = null;// loitering objects
		if (size == data.length >> 2 && data.length >> 1 != 0)// 防止複雜度震盪，當元素個數為容量的1/4時才執行縮容
			resize(data.length >> 1);// 實現對半縮容
		return temp;
	}

	// 刪除陣列第一個元素,返回刪除元素
	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("元素個數：%d,容量大小：%d\n", size, data.length));
		res.append('[');
		for (int i = 0; i < size; i++) {
			res.append(data[i]);
			if (i != size - 1)
				res.append(",");
		}
		res.append(']');
		return res.toString();
	}

	// 定義陣列擴容方法
	private void resize(int newCapacity) {
		E[] newData = (E[]) new Object[newCapacity];
		for (int i = 0; i < size; i++)
			newData[i] = data[i];
		data = newData;// 將新陣列的地址指向舊陣列
	}
}
 

-----------------------------------------------------------------------------------------------------------------------------------------------

簡單時間複雜度分析：

①新增操作（刪除操作等同）

addLast（e）           可能觸發resize擴容操作，最壞時間複雜的為O（n）

addFirst（e）           O（n）

add（index，e）      O（n/2）=O（n）

②修改操作

set（index，e）       O（1）

③查詢操作

get（index）             O（1）

contains（e）           O（n）

find（e）                   O（n）

總結：查詢快速，新增刪除賊慢

-----------------------------------------------------------------------------------------------------------------------------------------------

均攤時間複雜度分析：

我們知道在呼叫addLast方法時，有可能會觸發resize擴容，因此最壞情況的時間複雜度是O（n），但是這樣其實是不合理的，因為每次addLast操作不一定都觸發resize；

假設capacity=n，每次都使用addLast作為新增操作，當n+1次addLast操作會觸發resize擴容，將前面n個元素複製到新陣列中，因此總共執行了2n+1次操作，平均每次addLast約等於進行了兩次基本操作；

這樣均攤計算，addLast操作的時間複雜度是O（1），在這個例子裡均攤計算比計算最壞情況更有意義；

同理，removeLast操作的均攤複雜度也是O（1）。

-----------------------------------------------------------------------------------------------------------------------------------------------

複雜度震盪：

當陣列已滿時執行addLast時擴容，又馬上執行removeLast導致縮容，會造成複雜度震盪，這樣來回操作，每一個操作的時間複雜度為O（n）。

解決方法：

只需當size=capacity/4時，才將capacity減半實現縮容。