前言
在前面的實現的動手寫個Java動態陣列裡，雖然對於使用者而言，看是實現了動態擴容的功能，實際上，只是依託底層寫的方法ensureCapacity在陣列容量不足的時候，對重新申請一個原陣列1.5倍容量的新陣列，再將原有陣列中存放的元素複製到新陣列來，陣列指標指向新陣列，從根本上來說，這並不是真正的動態。
同時，陣列的拷貝，以及陣列申請的空間並未全部儲存元素，會降低效率，也會造成記憶體空間的浪費，但這對於連結串列來說，並不是個問題，連結串列是做到了用多少記憶體就申請多少記憶體空間，這才是真正的動態資料結構。
概念
什麼是連結串列？
連結串列是一種鏈式儲存的線性表，所有元素的記憶體地址不一定是連續的
連結串列的結構
對連結串列而言，資料是儲存在“結點”（Node）中的，可以使用一個資料域來儲存資料，這裡我稱為 element；然後結點中還有一個用來指向下一個結點位置的結點域，一般稱為 next。而對於連結串列的結尾，一般是以 NULL 作為結尾，所以連結串列中的最後一個結點的結點域 next 指向的是 NULL，圖示連結串列結構：
連結串列的設計
/**
* 定義連結串列第一結點，指向連結串列頭一個元素
*/
private Node<E> first;
/**
* 定義結點類Node，包含元素和指向下一個結點的地址引用
* @param <E>
*/
private static class Node<E>{
E element;
Node<E> next;
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
Node類是連結串列中結點的定義，first節點，size並不是儲存連結串列元素，而是用於儲存連結串列的元素數量，在上一節動手實現Java動態陣列的時候說到了，連結串列的大部分介面和動態陣列是一致的，Java語言長久不衰的原因有一點就是使用Java這種靜態編譯型的語言能夠寫出可維護性高的程式碼，提倡OCP原則，面向介面程式設計，面向抽象程式設計。
在這裡把連結串列和動態陣列是一致的方法及屬性抽取成List介面和AbstractList抽象類，畫一下類圖關係：
List介面中定義的屬性與方法
1、屬性：
int ELEMENT_NOT_FOUND = -1;—— 查無元素的返回標誌
2、介面方法：
int size();—— 查詢當前連結串列元素的數量boolean isEmpty();—— 判斷連結串列是否為空E set(int index, E element);—— 設定index位置的元素E get(int index);—— 獲取index位置的元素boolean contains(E element);—— 是否包含element元素int indexOf(E element);—— 檢視元素的索引void add(E element);—— 新增元素到尾部void add(int index, E element);—— 在index位置插入一個元素E remove(int index);—— 刪除index位置的元素void clear();—— 清除所有元素
AbstractList抽象類定義的屬性與方法
將不影響編碼的共同方法，在抽象類AbstractList實現，其他方法放到連結串列類LinkedList或動態陣列DynamicArray具體編碼實現，這樣做的好處就是，提高了程式碼的複用性和可維護性
1、屬性：
protected int size;—— 查無元素的返回標誌
2、抽象類方法：
int size();—— 查詢當前連結串列元素的數量boolean isEmpty();—— 判斷連結串列是否為空boolean contains(E element);—— 是否包含element元素void add(E element);—— 新增元素到尾部protected void outOfBounds(int index)—— 非法索引訪問丟擲異常protected void rangeCheck(int index)—— 索引檢查函式protected void rangeCheckForAdd(int index)—— 新增元素的索引檢查函式
LinkedList連結串列類定義的屬性與方法
1、屬性
private Node<E> first;—— 定義連結串列第一結點，指向連結串列頭一個元素
2、方法
E set(int index, E element);—— 設定index位置的元素E get(int index);—— 獲取index位置的元素int indexOf(E element);—— 檢視元素的索引void add(int index, E element);—— 在index位置插入一個元素E remove(int index);—— 刪除index位置的元素public E remove(E element);—— 刪除指定元素void clear();—— 清除所有元素private Node<E> node(int index)—— 獲取index位置對應的結點物件
完成設計後，是具體的方法編碼實現，一些簡單的方法在這裡就不作解釋了，註釋已經很清楚了，這裡講一些重點的方法
連結串列初始化
定義在LinkedList 中的private Node<E> first; 以及抽象父類AbstractList中的protected int size;是組成連結串列的第一結點，在沒有新增元素結點之前，它的值是這樣的：
再看一下void add(int index, E element);方法，這是向指定索引新增元素的方法，我們往指定索引新增元素時，需要找到該索引前的節點，再修改指標指向，完成新增元素結點的操作，將該操作提取成private Node<E> node(int index)方法。
講一下node方法吧，首先這裡，我們要明白，first是一個地址引用，也就是連結串列第一節結點，如果size為0，first指向的是null,如果size不為0，則指向的是連結串列頭結點，來看看node的程式碼實現：
/**
* 獲取index位置對應的結點物件
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
要查詢index索引位置的結點，從first出發，需要next尋找index次，例如我們查詢索引為2的結點，過程如下圖：
講完上面的方法，回到add方法，新增的過程是將新結點指向要插入的索引結點，修改索引前一結點的指向，將其指向新結點，然後size++，這裡依據index = 0條件成立與否要劃分兩種情況，因為index = 0 ,前面是沒有元素結點的，只有first節點地址引用，上程式碼，分析：
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
if (index == 0){
first = new Node<>(element,first);
}else {
Node<E> prev = node(index - 1);
prev.next = new Node<>(element,prev.next);
}
size++;
}
如果index != 0,就很好理解了，先是Node<E> prev = node(index - 1);，找到索引位置的前一結點，然後修改指標指向，prev.next = new Node<>(element,prev.next);，畫圖解釋：
當然index = 0 ，也是很好理解的，這裡以size = 0,index = 0 為例，畫圖演示：
刪除結點，和新增的原理是差不多的，這裡就不畫圖解說了。看完上面對於幾個重點方法的分析後，相信對於上面連結串列的結構就不會帶有疑惑了
完整程式碼
List介面
public interface List<E> {
//查無元素的返回標誌
int ELEMENT_NOT_FOUND = -1;
/**
* 元素的數量
* @return
*/
int size();
/**
* 是否為空
* @return
*/
boolean isEmpty();
/**
* 設定index位置的元素
* @param index
* @param element
* @return 原來的元素ֵ
*/
E set(int index, E element);
/**
* 獲取index位置的元素
* @param index
* @return
*/
E get(int index);
/**
* 是否包含某個元素
* @param element
* @return
*/
boolean contains(E element);
/**
* 檢視元素的索引
* @param element
* @return
*/
int indexOf(E element);
/**
* 新增元素到尾部
* @param element
*/
void add(E element);
/**
* 在index位置插入一個元素
* @param index
* @param element
*/
void add(int index, E element);
/**
* 刪除index位置的元素
* @param index
* @return
*/
E remove(int index);
/**
* 刪除指定元素
* @param element
* @return
*/
public E remove(E element);
/**
* 清除所有元素
*/
void clear();
}
抽象父類設計
抽象父類AbstractList是對介面List的實現
public abstract class AbstractList<E> implements List<E> {
/**
* 元素的數量
*/
protected int size;
/**
* 元素的數量
* @return
*/
public int size() {
return size;
}
/**
* 是否為空
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某個元素
* @param element
* @return
*/
public boolean contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 新增元素到尾部
* @param element
*/
public void add(E element) {
add(size, element);
}
/**
* 非法索引訪問陣列異常
* @param index
*/
protected void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
/**
* 索引檢查函式
* @param index
*/
protected void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
/**
* 陣列新增元素的索引檢查函式
* @param index
*/
protected void rangeCheckForAdd(int index) {
//index > size,元素可以新增在陣列size位置，即陣列尾部下一儲存單元
if (index < 0 || index > size) {
outOfBounds(index);
}
}
}
連結串列—LinkedList
public class LinkedList<E> extends AbstractList<E> {
/**
* 定義連結串列第一結點，指向連結串列頭一個元素
*/
private Node<E> first;
/**
* 定義結點類Node，包含元素和指向下一個結點的地址引用
* @param <E>
*/
private static class Node<E>{
E element;
Node<E> next;
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
/**
* 設定index位置的元素
*
* @param index
* @param element
* @return 原來的元素ֵ
*/
@Override
public E set(int index, E element) {
Node<E> node = node(index);
E old = node.element;
node.element = element;
return old;
}
/**
* 獲取index位置的元素
*
* @param index
* @return
*/
@Override
public E get(int index) {
return node(index).element;
}
/**
* 檢視元素的索引
*
* @param element
* @return
*/
@Override
public int indexOf(E element) {
//如果元素為空
if (element == null){
Node<E> node = first;
for (int i = 0;i < size;i++){
if (node.element == null) return i;
node = node.next;
}
}else {
//元素不為空
Node<E> node = first;
for (int i = 0;i < size;i++){
if (element.equals(node.element)) return i;
node = node.next;
}
}
//查無此元素
return ELEMENT_NOT_FOUND;
}
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
if (index == 0){
first = new Node<>(element,first);
}else {
Node<E> prev = node(index - 1);
prev.next = new Node<>(element,prev.next);
}
size++;
}
/**
* 刪除index位置的元素
*
* @param index
* @return
*/
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node =first;
if (index == 0){
first = first.next;
}else {
Node<E> prev = node(index - 1);
node = prev.next;
prev.next = node.next;
}
size--;
return node.element;
}
/**
* 刪除指定元素
*
* @param element
* @return
*/
@Override
public E remove(E element) {
return remove(indexOf(element));
}
/**
* 清除所有元素
*/
@Override
public void clear() {
size = 0;
first =null;
}
/**
* 獲取index位置對應的結點物件
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(node.element);
node = node.next;
}
string.append("]");
return string.toString();
}
}
虛擬頭結點
概念
改進連結串列：建立帶有虛擬頭結點的連結串列
Why：有時候為了讓程式碼更加精筒，統一所有節點的處理邏輯，可以在最前面增加一個虛擬的頭結點（不儲存資料）
類圖關係： 在繼承關係與抽象介面設計上，Virtual_LinkedList與LinkedList一樣，並未改動
結構設計
帶虛擬頭結點連結串列的結構
Virtual_LinkedList 連結串列類定義的屬性與方法
1、屬性
private Node<E> first;—— 定義連結串列第一結點，指向連結串列頭一個元素
2、方法
-
public Virtual_LinkedList()—— 構造方法，用於初始化建立虛擬頭結點 -
E set(int index, E element);—— 設定index位置的元素 -
E get(int index);—— 獲取index位置的元素 -
int indexOf(E element);—— 檢視元素的索引 -
void add(int index, E element);—— 在index位置插入一個元素 -
E remove(int index);—— 刪除index位置的元素 -
public E remove(E element);—— 刪除指定元素 -
void clear();—— 清除所有元素 -
private Node<E> node(int index)—— 獲取index位置對應的結點物件
方法變動
1、第一個需要變動的地方是增加構造方法public Virtual_LinkedList()，用於初始化建立虛擬頭結點
/**
* 建構函式，無論有無資料都要建立虛擬頭結點
*/
public Virtual_LinkedList() {
first = new Node<>(null,null);
}
2、變動方法 — private Node<E> node(int index)
前面說到該方法是通過index索引對應的結點物件,是從索引為 0 的元素結點開始查詢，現在是從虛擬頭結點開始遍歷查詢，指標應該從first改為first.next,讓指標還是指向索引為 0 的元素結點
/**
* 獲取index位置對應的結點物件
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
Node<E> node = first.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
3、變動方法 — public int indexOf(E element)，增加了頭結點，遍歷時應該從fiirst.next開始
/**
* 檢視元素的索引
*
* @param element
* @return
*/
@Override
public int indexOf(E element) {
//如果元素為空
if (element == null){
Node<E> node = first.next;
for (int i = 0;i < size;i++){
if (node.element == null) return i;
node = node.next;
}
}else {
//元素不為空
Node<E> node = first.next;
for (int i = 0;i < size;i++){
if (element.equals(node.element)) return i;
node = node.next;
}
}
//查無此元素
return ELEMENT_NOT_FOUND;
}
4、變動方法 — void add(int index, E element);
之前我們說到新增新結點的方法的思想，是要找到插入的索引位置的前一位置，再來改動指標指向，但是索引為 0 的位置，前面是沒有元素結點了，所以這種情況是不通用的，需要根據index == 0的情況分為兩種情況，但是有了虛擬頭結點，那就變成通用的了，同時也是精簡了程式碼，統一所有結點的處理邏輯
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
//這裡區分index = 0，是為了應對索引檢查函式，node(0 - 1)，-1是沒法通過檢查的，但是新增的邏輯是統一的
Node<E> prev = (index == 0 ? first : node(index - 1));
prev.next = new Node<>(element,prev.next);
size++;
}
5、變動方法 — E remove(int index);同樣的，刪除方法也是跟 add方法一樣，統一所有結點的處理邏輯
/**
* 刪除index位置的元素
*
* @param index
* @return
*/
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node;
Node<E> prev =(index == 0 ? first : node(index - 1));
node = prev.next;
prev.next = node.next;
size--;
return node.element;
}
雙向連結串列
概念
此前，我們在上面編寫的都是單向連結串列，缺點是比較明顯的，每次是獲取結點元素都需要從頭結點開始遍歷。而使用雙向連結串列能有效的提升連結串列的綜合效能
類圖關係： 在繼承關係與抽象介面設計上，Both_LinkedList與LinkedList一樣，並未改動
雙向連結串列設計
/**
* 定義連結串列尾結點指標，指向連結串列尾元素
*/
private Node<E> last;
/**
* 定義結點類Node，包含元素和指向下一個結點的地址引用
* @param <E>
*/
private static class Node<E>{
E element;
Node<E> prev;
Node<E> next;
public Node(Node<E> prev, E element, Node<E> next) {
this.prev = prev;
this.element = element;
this.next = next;
}
}
方法變動
1、變動方法 — private Node<E> node(int index)
此前的node方法，由於是單向連結串列，所以都是從頭開始遍歷尋找，現在是雙向連結串列，根據索引位於中間結點位置的前後，決定遍歷方向
/**
* 獲取index位置對應的結點物件
* @param index
* @return
*/
private Node<E> node(int index){
rangeCheck(index);
//如果查詢的元素在連結串列前半部分
if (index < (size >> 1)) {
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
} else {
//如果查詢的元素在連結串列後半部分
Node<E> node = last;
for (int i = size - 1; i > index; i--) {
node = node.prev;
}
return node;
}
}
2、變動方法 — void add(int index, E element);
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
//往最後面新增元素
if (index == size) {
Node<E> oldLast = last;
last = new Node<>(oldLast, element, null);
//這是連結串列新增的第一個元素
if (oldLast == null) {
first = last;
} else {
oldLast.next = last;
}
} else {
Node<E> next = node(index);
Node<E> prev = next.prev;
Node<E> node = new Node<>(prev, element, next);
next.prev = node;
//index == 0，往最前面新增
if (prev == null) {
first = node;
} else {
prev.next = node;
}
}
size++;
}
按照 3 種情形分析，通用的插入於中間位置，插入index == 0頭部位置，和插入index == size尾部部位置
1、插入中間位置
2、插入頭部位置
3、插入尾部位置
這裡需要注意的是，如果此時的雙向連結串列是空連結串列，那麼尾部插入的就是第一個元素
3、變動方法 — E remove(int index);
事實上，移除結點元素也是跟上面的新增元素一樣，在這裡就不畫圖做解釋了，讀一遍程式碼不懂的話，可以看著雙向連結串列結構圖，讀或者DeBug一遍
/**
* 刪除index位置的元素
*
* @param index
* @return
*/
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node = node(index);
Node<E> prev = node.prev;
Node<E> next = node.next;
// index == 0
if (prev == null){
first = next;
}else {
prev.next = next;
}
// index == size - 1
if (next == null){
last = prev;
}else {
next.prev = prev;
}
size--;
return node.element;
}
迴圈連結串列
單向迴圈連結串列
結構設計：
方法變動：
1、變動方法 — void add(int index, E element);
實際上，單向迴圈連結串列只是在單向連結串列的基礎上，將尾結點的next指向頭結點，所以新增操作只需要注意往頭結點插入的情況改動方法就好，注意點有兩個，index == 0``size == 0
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
if (index == 0){
first = new Node<>(element,first);
Node<E> last =(size == 0) ? first : node(size - 1);
last.next = first;
}else {
Node<E> prev = node(index - 1);
prev.next = new Node<>(element,prev.next);
}
size++;
}
當size == 0,新增的操作就是下圖的樣子，同時當連結串列只有一個結點時，也是刪除要注意的點
1、變動方法 — public E remove(int index);
/**
* 刪除index位置的元素
*
* @param index
* @return
*/
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node = first;
if (index == 0) {
if (size == 1) {
first = null;
} else {
Node<E> last = node(size - 1);
first = first.next;
last.next = first;
}
} else {
Node<E> prev = node(index - 1);
node = prev.next;
prev.next = node.next;
}
size--;
return node.element;
}
雙向迴圈連結串列
結構設計：
方法變動：
1、變動方法 — void add(int index, E element);
實際上，雙向迴圈連結串列只是在雙連結串列的基礎上，將尾結點的next指向頭結點，頭結點的prev指向尾結點，所以其實很多都是不變的，我們只需要關注新增操作與刪除操作就好了
/**
* 在index位置插入一個元素
*
* @param index
* @param element
*/
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
//往最後面新增元素
if (index == size) {
Node<E> oldLast = last;
last = new Node<>(oldLast, element, first);
//這是連結串列新增的第一個元素
if (oldLast == null) {
first = last;
first.next = first;
first.prev = first;
} else {
oldLast.next = last;
first.prev = last;
}
} else {
Node<E> next = node(index);
Node<E> prev = next.prev;
Node<E> node = new Node<>(prev, element, next);
next.prev = node;
prev.next = node;
//index == 0，往最前面新增
if (index == 0) {
first = node;
}
}
size++;
}
注意當size == 0，插入連結串列的頭結點指標指向如下
1、變動方法 — public E remove(int index);
/**
* 刪除index位置的元素
*
* @param index
* @return
*/
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node = first;
if (size == 1){
first = null;
last = null;
}else {
node = node(index);
Node<E> prev = node.prev;
Node<E> next = node.next;
prev.next = next;
next.prev = prev;
// index == 0
if (node == first){
first = next;
}
// index == size - 1
if (node == last){
last = prev;
}
}
size--;
return node.element;
}
小結
單向連結串列 VS 雙向連結串列
粗略對比一下刪除的運算元量：
相比之下，雙向連結串列的操作縮減了一半，但是其佔用的記憶體空間也增加了
動態陣列 VS 連結串列
1、動態陣列：開闢、銷燬記憶體空間的次數相對較少，但可能造成記憶體空間浪費（可以通過縮容解決）
2、雙向連結串列：開闢、銷燬記憶體空間的次數相對較多，但不會造成記憶體空間的浪費
應用場景：
-
如果頻繁在尾部進行新增、刪除操作，動態陣列、雙向連結串列均可選擇
-
如果頻繁在頭部進行新增、刪除操作，建議選擇使用雙向連結串列
-
如果有頻繁的（在任意位置）新增、刪除操作，建議選擇使用雙向連結串列
-
如果有頻繁的查詢操作（隨機訪問操作），建議選擇使用動態陣列
宣告
個人能力有限，有不正確的地方，還請指正
文章為原創，歡迎轉載，註明出處即可
本文的程式碼已上傳github,歡迎star