链表

链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成

如下图：

相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表时需要额外注意。在数组中，我们可以直接访问任何位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。

创建链表

 1 // 待实现功能
 2 // push(element)：向链表尾部添加一个新元素。
 3 // insert(element, position)：向链表的特定位置插入一个新元素。
 4 // getElementAt(index)：返回链表中特定位置的元素。如果链表中不存在这样的元素，则返回 undefined。 
 5 // remove(element)：从链表中移除一个元素。
 6 // indexOf(element)：返回元素在链表中的索引。如果链表中没有该元素则返回-1。
 7 // removeAt(position)：从链表的特定位置移除一个元素。
 8 // isEmpty()：如果链表中不包含任何元素，返回 true，如果链表长度大于0则返回 false。 
 9 // size()：返回链表包含的元素个数，与数组的 length 属性类似。
10 // toString()：返回表示整个链表的字符串。

  1 function defaultEquals(a, b){
  2     // 用于比较链表中元素是否相等
  3     return a===b
  4 }
  5 
  6 class Node{
  7     // 节点
  8     constructor(element){
  9         this.element = element
 10         this.next = undefined
 11     }
 12 }
 13 
 14 class LinkedList{
 15     // 链表
 16     constructor(equalsFn = defaultEquals){
 17         this.count = 0      // 长度
 18         this.head = undefined   // 头元素
 19         this.equalsFn = equalsFn
 20     }
 21 
 22     push(element){
 23         // 向链表末尾添加一个元素
 24         // 1.链表为空，添加为头部元素
 25         // 2.链表不为空，追加元素
 26         const node = new Node(element)
 27         let current
 28         if(!this.head){
 29             // 如果没有头元素,则直接插入头部
 30             this.head = node
 31         }else{
 32             // 如果有头元素,则依次查找至末尾,添加到末尾处
 33             current = this.head
 34             while(current.next){
 35                 current = current.next
 36             }
 37             current.next = node
 38         }
 39         this.count++
 40     }
 41     getElementAt(index){
 42         if(index >= 0 && index < this.count){
 43             let node = this.head
 44             for(let i = 0; i < index && node; i++){
 45                 node = node.next
 46             }
 47             return node
 48         }else{
 49             return undefined
 50         }
 51     }
 52     removeAt(index){
 53         // 删除指定索引处的元素,返回删除元素
 54         let current = this.head
 55         if (index === 0){
 56             // 若待删除索引为0,则直接替换头元素
 57             this.head = current.next
 58         }else{
 59             // 若索引不为0,查找至待删除索引上一位，直接连接待删除索引下一位
 60             const previous = this.getElementAt(index-1)
 61             current = previous.next
 62             previous.next = current.next    // 去除index处元素
 63         }
 64         this.count--
 65         return current.element        
 66     }
 67     insert(element, index){
 68         if(0 <= index <= this.count){
 69             const node = new Node(element)
 70             if(index === 0){
 71                 const current = this.head
 72                 node.next = current
 73                 this.head = node
 74             }else{
 75                 const previous = this.getElementAt(index-1)
 76                 const current = previous.next
 77                 node.next = current
 78                 previous.next = node
 79             }
 80             this.count++
 81             return true
 82         }
 83         return false
 84     }
 85     indexOf(element){
 86         let current = this.head
 87         for(let i = 0; i < this.count; i++){
 88             if (this.equalsFn(current.element, element)) {
 89                 return i
 90             }
 91             current = current.next
 92         }
 93         return -1
 94     }
 95     remove(element){
 96         // 移除某个元素
 97         const index = this.indexOf(element)
 98         return this.removeAt(index)
 99     }
100     isEmpty(){
101         return this.count === 0
102     }
103     size(){
104         return this.count
105     }
106     getHead(){
107         return this.head
108     }
109     toString(){
110         // toString方法
111         if(!this.head){
112             return ""
113         }else{
114             let str = `${this.head.element}`
115             let current = this.head.next
116             for(let i = 1; i < this.size() && current !== null; i++){
117                 str = `${str},${current.element}`
118                 current=current.next
119             }
120             return str
121         }
122     }
123 
124 }

双向链表

双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接；而在双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素

对单向链表进行扩展，主要重写插入和删除方法，需要考虑每个节点有向前的指针

 1 class DoubleLinkedList extends LinkedList{
 2     constructor(equalsFn = defaultEquals){
 3         super(equalsFn)
 4         this.tail = undefined   // 最后一个节点
 5     }
 6     insert(element, index){
 7         // 在任意位置添加新元素
 8         if(index >=0 && index <= this.count){   // 索引是否超限
 9             const node = new DoubleNode(element)
10             let current = this.head
11             if (index === 0) {  
12                 // 若索引为0
13                 if (!this.head) {
14                     // 空链表则直接加到头部
15                     this.head = node
16                     this.tail = node
17                 }else{
18                     node.next = this.head
19                     current.prev = node
20                     this.head = node
21                 }
22             }else if(index === this.count){
23                 // 若索引为最后
24                 current =this.tail
25                 current.next = node
26                 node.prev = current
27                 this.tail = node
28             }else{
29                 // 其余索引
30                 const previous = this.getElementAt(index - 1)
31                 current = previous.next
32                 node.next = current
33                 node.prev = previous
34                 previous.next = node
35                 current.prev = node
36             }
37             this.count++
38             return true
39         }
40         return false
41     }
42     removeAt(index){
43         // 按索引删除
44         if(index >= 0 && index < this.count){    // 索引是否超限
45             let current = this.head     
46             if(index === 0){
47                 // 删除头元素
48                 this.head = current.next
49                 if (this.count === 1) {
50                     // 若只有一个元素
51                     this.tail = undefined
52                 }else{
53                     this.head.prev = undefined
54                 }
55             }else if(index === this.count - 1){
56                 // 删除末尾元素
57                 current = this.tail
58                 this.tail = current.prev
59                 this.tail.next = undefined
60             }else{
61                 current = this.getElementAt(index)
62                 const previous = current.prev
63                 previous.next = current.next
64                 current.next.prev = previous
65             }
66             this.count--
67             return current.element
68         }
69         return undefined
70     }
71 }

有序链表

有序链表是指保持元素有序的链表结构。新元素将按照固定的排序算法插入

 1 function defaultEquals(a, b){
 2     // 用于比较链表中元素是否相等
 3     return a===b
 4 }
 5 
 6 const compare = {
 7     Less_Than : -1,
 8     Bigger_Than : 1
 9 }
10 
11 function defaultCompare(a, b){
12     // 比较大小
13     if(a === b){
14         return 0
15     }
16     return a < b? compare.Less_Than : compare.Bigger_Than
17 }
18 
19 class SortedLinkedList extends LinkedList{
20     constructor(equalsFn = defaultEquals, compareFn = defaultCompare){
21         super(equalsFn)
22         this.compareFn = compareFn
23     }
24 
25     // 因为自动排序，所以要重写insert
26     insert(element){
27         if(this.isEmpty){
28             // 若是空链表，则直接插入即可
29             return super.insert(element, 0)
30         }else{
31             // 若不是空链表，则插入排序后的位置
32             return super.insert(element, getIndexNextSortedElement(element))
33         }
34 
35     }
36 
37     getIndexNextSortedElement(element){
38         // 排序，找到元素的位置
39         let current = this.head
40         let i = 0
41         for(; i < this.size() && current; i++){
42             const comp = this.compareFn(element, current.element)
43             if (comp === compare.Less_Than) {
44                 return i
45             }
46             current = current.next
47         }
48         return i
49     }
50 
51 
52 }

使用链表实现栈数据结构

 1 class StackLinkedList{
 2     constructor(){
 3         this.items = new DoubleLinkedList()
 4     }
 5     push(element){
 6         this.items.insert(this.items.size())
 7     }
 8     pop(){
 9         if (!this.items.isEmpty()) {
10             return undefined
11         }
12         this.items.removeAt(this.size()-1)
13     }
14     // 使用双向链表实现栈数据结构比单向链表简单的多，同样也可实现队列
15 
16 }