上一篇部落格《學習 JS 資料結構(1)：棧和佇列》說了棧和佇列在JS中的實現，我們運用JS提供的API很容易的實現了棧和佇列，但這種資料結構有一個很明顯的缺點，因為陣列大小是固定的，所以我們在移除或是新增一項資料的時候成本很高，基本都需要把資料重排一次。(JS的Array類方法雖然很方便但背後的原理同樣是這樣的)
相比陣列我們今天主角——連結串列就要來的隨性多，簡單的理解可以是這樣：在記憶體中，棧和佇列（陣列）的存在就是一個整體，如果想要對她內部某一個元素進行移除或是新增一個新元素，就要動她內部所有的元素，所謂牽一髮而動全身；而連結串列則不一樣，每一個元素都是由元素本身資料和指向下一個元素的指標構成，所以新增或是移除某一個元素不需要對連結串列整體進行操作，只需要改變相關元素的指標指向就可以了。
連結串列在實際生活中的例子也有很多，比如自行車的鏈條，環環相扣，但新增或是移除某一個環節只需要對症下藥，對相關環節進行操作就OK。再比如：火車，火車就是一個連結串列，每一節車廂就是元素，想要移除或是新增某一節車廂，只需要把連線車廂的鏈條改變一下就好了。那麼，在 JS 中又該怎麼去實現連結串列結構呢？
連結串列的建立
首先我們要建立一個連結串列類：
|
1 2 3 |
function LinkedList(){ //各種屬性和方法的宣告 } |
然後我們需要一種資料結構來儲存連結串列裡面的資料：
|
1 2 3 4 5 |
var Node=function(element){ this.element=element; this.next=null; } //Node類表示要新增的元素，他有兩個屬性，一個是element，表示新增到連結串列中的具體的值；另一個是next,表示要指向連結串列中下一個元素的指標。 |
接下來，我們需要給連結串列宣告一些方法：
- append(element):向連結串列尾部新增一個新的元素；
- insert(position,element):向連結串列特定位置插入元素；
- remove(element):從連結串列移除一項；
- indexOf(element):返回連結串列中某元素的索引，如果沒有返回-1；
- removeAt(position):從特定位置移除一項；
- isEmpty():判斷連結串列是否為空，如果為空返回true,否則返回false;
- size():返回連結串列包含的元素個數；
- toString():重寫繼承自Object類的toString()方法，因為我們使用了Node類；
連結串列的完整程式碼：
|
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 |
function LinkedList() { //Node類宣告 let Node = function(element){ this.element = element; this.next = null; }; //初始化連結串列長度 let length = 0; //初始化第一個元素 let head = null; this.append = function(element){ //初始化新增的Node例項 let node = new Node(element), current; if (head === null){ //第一個Node例項進入連結串列，之後在這個LinkedList例項中head就不再是null了 head = node; } else { current = head; //迴圈連結串列知道找到最後一項，迴圈結束current指向連結串列最後一項元素 while(current.next){ current = current.next; } //找到最後一項元素後，將他的next屬性指向新元素node,j建立連結 current.next = node; } //更新連結串列長度 length++; }; this.insert = function(position, element){ //檢查是否越界，超過連結串列長度或是小於0肯定不符合邏輯的 if (position >= 0 && position <= length){ let node = new Node(element), current = head, previous, index = 0; if (position === 0){ //在第一個位置新增 node.next = current; head = node; } else { //迴圈連結串列，找到正確位置，迴圈完畢，previous，current分別是被新增元素的前一個和後一個元素 while (index++ < position){ previous = current; current = current.next; } node.next = current; previous.next = node; } //更新連結串列長度 length++; return true; } else { return false; } }; this.removeAt = function(position){ //檢查是否越界，超過連結串列長度或是小於0肯定不符合邏輯的 if (position > -1 && position < length){ let current = head, previous, index = 0; //移除第一個元素 if (position === 0){ //移除第一項，相當於head=null; head = current.next; } else { //迴圈連結串列，找到正確位置，迴圈完畢，previous，current分別是被新增元素的前一個和後一個元素 while (index++ < position){ previous = current; current = current.next; } //連結previous和current的下一個元素，也就是把current移除了 previous.next = current.next; } length--; return current.element; } else { return null; } }; this.indexOf = function(element){ let current = head, index = 0; //迴圈連結串列找到元素位置 while (current) { if (element === current.element) { return index; } index++; current = current.next; } return -1; }; this.remove = function(element){ //呼叫已經宣告過的indexOf和removeAt方法 let index = this.indexOf(element); return this.removeAt(index); }; this.isEmpty = function() { return length === 0; }; this.size = function() { return length; }; this.getHead = function(){ return head; }; this.toString = function(){ let current = head, string = ''; while (current) { string += current.element + (current.next ? ', ' : ''); current = current.next; } return string; }; this.print = function(){ console.log(this.toString()); }; } //一個例項化後的連結串列，裡面是新增的數個Node類的例項 |
ES6版本:
|
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 |
let LinkedList2 = (function () { class Node { constructor(element){ this.element = element; this.next = null; } } //這裡我們使用WeakMap物件來記錄長度狀態 const length = new WeakMap(); const head = new WeakMap(); class LinkedList2 { constructor () { length.set(this, 0); head.set(this, null); } append(element) { let node = new Node(element), current; if (this.getHead() === null) { head.set(this, node); } else { current = this.getHead(); while (current.next) { current = current.next; } current.next = node; } let l = this.size(); l++; length.set(this, l); } insert(position, element) { if (position >= 0 && position <= this.size()) { let node = new Node(element), current = this.getHead(), previous, index = 0; if (position === 0) { node.next = current; head.set(this, node); } else { while (index++ < position) { previous = current; current = current.next; } node.next = current; previous.next = node; } let l = this.size(); l++; length.set(this, l); return true; } else { return false; } } removeAt(position) { if (position > -1 && position < this.size()) { let current = this.getHead(), previous, index = 0; if (position === 0) { head.set(this, current.next); } else { while (index++ < position) { previous = current; current = current.next; } previous.next = current.next; } let l = this.size(); l--; length.set(this, l); return current.element; } else { return null; } } remove(element) { let index = this.indexOf(element); return this.removeAt(index); } indexOf(element) { let current = this.getHead(), index = 0; while (current) { if (element === current.element) { return index; } index++; current = current.next; } return -1; } isEmpty() { return this.size() === 0; } size() { return length.get(this); } getHead() { return head.get(this); } toString() { let current = this.getHead(), string = ''; while (current) { string += current.element + (current.next ? ', ' : ''); current = current.next; } return string; } print() { console.log(this.toString()); } } return LinkedList2; })(); |
雙向連結串列
|
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 148 149 |
function DoublyLinkedList() { let Node = function(element){ this.element = element; this.next = null; this.prev = null; //NEW }; let length = 0; let head = null; let tail = null; //NEW this.append = function(element){ let node = new Node(element), current; if (head === null){ head = node; tail = node; //NEW } else { //NEW tail.next = node; node.prev = tail; tail = node; } length++; }; this.insert = function(position, element){ if (position >= 0 && position <= length){ let node = new Node(element), current = head, previous, index = 0; if (position === 0){ if (!head){ //NEW head = node; tail = node; } else { node.next = current; current.prev = node; //NEW head = node; } } else if (position === length) { ////NEW current = tail; current.next = node; node.prev = current; tail = node; } else { while (index++ < position){ previous = current; current = current.next; } node.next = current; previous.next = node; current.prev = node; //NEW node.prev = previous; //NEW } length++; return true; } else { return false; } }; this.removeAt = function(position){ if (position > -1 && position < length){ let current = head, previous, index = 0; if (position === 0){ //NEW if (length === 1){ // tail = null; } else { head.prev = null; } } else if (position === length-1){ //NEW current = tail; tail = current.prev; tail.next = null; } else { while (index++ < position){ previous = current; current = current.next; } previous.next = current.next; current.next.prev = previous; //NEW } length--; return current.element; } else { return null; } }; this.remove = function(element){ let index = this.indexOf(element); return this.removeAt(index); }; this.indexOf = function(element){ let current = head, index = -1; if (element == current.element){ return 0; } index++; while(current.next){ if (element == current.element){ return index; } current = current.next; index++; } //check last item if (element == current.element){ return index; } return -1; }; this.isEmpty = function() { return length === 0; }; this. size = function() { return length; }; this.toString = function(){ let current = head, s = current ? current.element : ''; while(current && current.next){ current = current.next; s += ', ' + current.element; } return s; }; this.inverseToString = function() { let current = tail, s = current ? current.element : ''; while(current && current.prev){ current = current.prev; s += ', ' + current.element; } return s; }; this.print = function(){ console.log(this.toString()); }; this.printInverse = function(){ console.log(this.inverseToString()); }; this.getHead = function(){ return head; }; this.getTail = function(){ return tail; } } |
雙向連結串列和單項比起來就是Node類多了一個prev屬性，也就是每一個node不僅僅有一個指向它後面元素的指標也有一個指向它前面的指標。
迴圈連結串列
明白了前面的基礎連結串列和雙向連結串列之後這個肯定不在話下了，迴圈，其實就是整個連結串列例項變成了一個圈，在單項鍊表中最後一個元素的next屬性為null,現在讓它指向第一個元素也就是head，那麼他就成了單向迴圈連結串列。在雙向連結串列中最後一個元素的next屬性為null,現在讓它指向第一個元素也就是head，那麼他就成了雙向迴圈連結串列。就那麼回事…
後記
說到現在一直都是線性表，就是順序資料結構，他們都是有順序的，資料都是一條繩子上的螞蚱。那麼，如果資料是沒有順序的呢？那又該使用哪種資料結構呢？這個放到[學習javascript資料結構(三)——集合]中學習。
打賞支援我寫出更多好文章，謝謝！
打賞作者
打賞支援我寫出更多好文章，謝謝！
任選一種支付方式
