成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

前端進階:從零實現單向 & 雙向鏈表

作者：徐小夕
開發 前端
鏈表是一種線性表數據結構，由一系列結點(鏈表中每一個元素稱為結點)組成，結點可以在運行時動態生成。每個結點包括兩個部分：一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。

[[397775]]

前言

前端工程師對于算法和數據結構這塊的知識的掌握程度，是進階高級工程師的非常重要的標志之一，為了總結一下數據結構和算法方面的知識，筆者今天繼續把鏈表這一塊的知識補上，也作為自己知識體系的一個梳理，筆者早在去年就寫過一篇關于使用javascript實現二叉樹和二叉搜索樹的文章，如果感興趣或者想進階高級的朋友們可以參考學習一下： JavaScript 中的二叉樹以及二叉搜索樹的實現及應用.

你將收獲

  • 鏈表的概念和應用
  • 原生javascript實現一條單向鏈表
  • 原生javascript實現一條個雙單向鏈表
  • 鏈表和數組的對比及優缺點

正文

1. 鏈表的概念和應用

鏈表是一種線性表數據結構，由一系列結點(鏈表中每一個元素稱為結點)組成，結點可以在運行時動態生成。每個結點包括兩個部分：一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。

以上概念用圖表示為以下結構：

鏈表是非連續的，所以說從底層存儲結構上看，它不需要一整塊連續的存儲空間，而是通過“指針”將一組零散的數據單元串聯起來成為一個整體。鏈表也有幾種不同的類型：單向鏈表，雙向鏈表，循環鏈表。上圖就是一種單向鏈表。由其定義不難發現雙向鏈表無非就是每個節點加上了前后節點的指針引用，如下圖所示：

那什么是循環鏈表呢?循環鏈表本質上是一種特殊的單向鏈表，唯一的區別就在于它的尾結點指向了鏈表的頭結點，這樣首尾相連，形成了一個環，所以叫做循環鏈表。如下圖所示：

當然我們還可以擴展出雙向循環鏈表，這里就不一一舉例了?？傊湵斫Y構在計算機底層語言中應用的比較多，當我們在用高級語言做編程時可能不會察覺，比如我們用javascript敲js的時候，其實我們在深入了解鏈表之后我們就會發現鏈表有很多應用場景，比如LRU 緩存淘汰，最近消息推送等。

舉個更接地氣的，當我們在用PS畫圖時軟件提供了一個動作面板，可以記錄用戶之前的操作記錄，并批量執行動作，或者當我們在使用編輯器時的回退撤銷功能等，用鏈表結構來存儲狀態信息還是比較方便的。

最近比較火的react hooks API，其結構也是一個鏈表型的數據結構，所以學習鏈表還是非常有幫助的。讀到這里可能還是有點懵，接下來我們先用js實現一個鏈表，這樣有助于理解鏈表的本質，后面筆者會總結一下鏈表和數組的對比以及優劣勢，方便大家對鏈表有一個更加直觀的認識。

2.原生javascript實現一條單向鏈表

在上面一節介紹的鏈表結構中大家可能對鏈表有了初步的認識，因為javascript中沒有鏈表的數據結構，為了模擬鏈表結構，我們可以通過js面向對象的方式實現一個鏈表結構及其API，具體設計如下：

有了以上需求點之后，這個鏈表才是基本可用的鏈表，那么我們一步步來實現它吧。

2.1 定義鏈表結構

為了實現鏈表以及鏈表的操作，首先我們需要先定義鏈表的基本結構，第一步就是定義節點的數據結構。我們知道一個節點會有自己的值以及指向下一個節點的引用，所以可以這樣定義節點：

  1. let Node = function(el) { 
  2.       this.el = el; 
  3.       this.next = null; 
  4.  } 

接下來我們定義一下鏈表的基本骨架：

  1. // 單向鏈表, 每一個元素都有一個存儲元素自身的節點和一個指向下一個元素引用的節點組成 
  2. function linkedList() { 
  3.   let Node = function(el) { 
  4.       this.el = el; 
  5.       this.next = null; 
  6.   } 
  7.   let length = 0 
  8.   let head = null  // 用來存儲第一個元素的引用 
  9.  
  10.   // 尾部添加元素 
  11.   this.append = (el) => {}; 
  12.   //插入元素 
  13.   this.insert = (pos, el) => {}; 
  14.   // 移除指定位置的元素 
  15.   this.removeAt = (pos) => {}; 
  16.   // 移除指定節點 
  17.   this.remove = (el) => {}; 
  18.   // 查詢節點所在位置 
  19.   this.indexOf = (el) => {}; 
  20.   // 判斷鏈表是否為空 
  21.   this.isEmpty = () => {}; 
  22.   // 返回鏈表長度 
  23.   this.size = () => {}; 
  24.   // 將鏈表轉化為數組返回 
  25.   this.toArray = () => {}; 
  26. } 

由以上代碼我們可以知道鏈表的初始長度為0，頭部元素為null，接下來我們實現添加節點的功能。

2.2 實現添加節點

追加節點的時候首先需要知道頭部節點是否存在，如果不存在直接賦值，存在的話則從頭部開始遍歷，直到找到下一個節點為空的節點，再賦值，并將鏈表長度+1，代碼如下：

  1. // 尾部添加元素 
  2. this.append = (el) => { 
  3.     let node = new Node(el), 
  4.         current; 
  5.     if(!head) { 
  6.       head = node 
  7.     }else { 
  8.       current = head; 
  9.       while(current.next) { 
  10.         current = current.next; 
  11.       } 
  12.       current.next = node; 
  13.     } 
  14.     length++ 
  15. }; 

2.3 實現插入節點

實現插入節點邏輯首先我們要考慮邊界條件，如果插入的位置在頭部或者比尾部位置還大，我們就沒必要從頭遍歷一遍處理了，這樣可以提高性能，所以我們可以這樣處理：

  1. //插入元素 
  2. this.insert = (pos, el) => { 
  3.     if(pos >=0 && pos <= length) { 
  4.       let node = new Node(el), 
  5.           previousNode = null, 
  6.           current = head, 
  7.           curIdx = 0; 
  8.       if(pos === 0) { 
  9.         node.next = current; 
  10.         head = node; 
  11.       }else { 
  12.         while(curIdx++ < pos) { 
  13.           previousNode = current; 
  14.           current = current.next; 
  15.         } 
  16.         node.next = current; 
  17.         previousNode.next = node; 
  18.         length++; 
  19.         return true 
  20.       } 
  21.     }else { 
  22.       return false 
  23.     } 
  24. }; 

2.4 根據節點的值查詢節點位置

根據節點的值查詢節點位置實現起來比較簡單，我們只要從頭開始遍歷，然后找到對應的值之后記錄一下索引即可：

  1. // 查詢節點所在位置 
  2. this.indexOf = (el) => { 
  3.     let idx = -1, 
  4.         curIdx = -1, 
  5.         current = head; 
  6.     while(current) { 
  7.       idx++ 
  8.       if(current.el === el) { 
  9.         curIdx = idx 
  10.         break; 
  11.       } 
  12.       current = current.next; 
  13.     } 
  14.     return curIdx 
  15. }; 

這里我們之所以要用idx和curIdx兩個變量來處理，是因為如果用戶傳入的值不在鏈表里，那么idx的值就會有問題，所以用curIdx來保證準確性。

2.5 移除指定位置的節點

移除指定位置的節點也需要判斷一下邊界條件，可插入節點類似，但要注意移除之后一定要將鏈表長度-1，代碼如下：

  1. // 移除指定位置的元素 
  2. this.removeAt = (pos) => { 
  3.     // 檢測邊界條件 
  4.     if(pos >=0 && pos < length) { 
  5.       let previousNode = null, 
  6.                current = head, 
  7.                curIdx = 0; 
  8.       if(pos === 0) { 
  9.         // 如果pos為第一個元素 
  10.         head = current.next 
  11.       }else { 
  12.         while(curIdx++ < pos) { 
  13.           previousNode = current; 
  14.           current = current.next; 
  15.         } 
  16.         previousNode.next = current.next; 
  17.       } 
  18.       length --; 
  19.       return current.el 
  20.     }else { 
  21.       return null 
  22.     } 
  23. }; 

2.6 移除指定節點

移除指定節點實現非常簡單，我們只需要利用之前實現好的查找節點先找到節點的位置，然后再用實現過的removeAt即可，代碼如下：

  1. // 移除指定節點 
  2. this.remove = (el) => { 
  3.   let idx = this.indexOf(el); 
  4.   this.removeAt(idx); 
  5. }; 

2.7 獲取節點長度

這里比較簡單，直接上代碼：

  1. // 返回鏈表長度 
  2. this.size = () => { 
  3.   return length 
  4. }; 

2.8 判斷鏈表是否為空

判斷鏈表是否為空我們只需要判斷長度是否為零即可：

  1. // 返回鏈表長度 
  2. this.size = () => { 
  3.   return length 
  4. }; 

2.9 打印節點

打印節點實現方式有很多，大家可以按照自己喜歡的格式打印，這里筆者直接將其打印為數組格式輸出，代碼如下：

  1. // 將鏈表轉化為數組返回 
  2. this.toArray = () => { 
  3.     let current = head, 
  4.         results = []; 
  5.     while(current) { 
  6.       results.push(current.el); 
  7.       current = current.next; 
  8.     } 
  9.     return results 
  10. };  

這樣，我們的單向鏈表就實現了，那么我們可以這么使用：

  1. let link = new linkedList() 
  2. // 添加節點 
  3. link.append(1) 
  4. link.append(2) 
  5. // 查找節點 
  6. link.indexOf(2) 
  7. // ... 

3.原生javascript實現一條個雙單向鏈表

有了單向鏈表的實現基礎，實現雙向鏈表也很簡單了，我們無非要關注的是雙向鏈表的節點創建，這里筆者實現一個例子供大家參考：

  1. let Node = function(el) { 
  2.       this.el = el; 
  3.       this.previous = null; 
  4.       this.next = null; 
  5.  } 
  6. let length = 0 
  7. let head = null  // 用來存儲頭部元素的引用 
  8. let tail = null  // 用來存儲尾部元素的引用 

由代碼可知我們在節點中會有上一個節點的引用以及下一個節點的引用，同時這里筆者添加了頭部節點和尾部節點方便大家操作。大家可以根據自己的需求實現雙向鏈表的功能，這里筆者提供一份自己實現的代碼，可以參考交流一下：

  1. // 雙向鏈表, 每一個元素都有一個存儲元素自身的節點和指向上一個元素引用以及下一個元素引用的節點組成 
  2. function doubleLinkedList() { 
  3.   let Node = function(el) { 
  4.       this.el = el; 
  5.       this.previous = null; 
  6.       this.next = null; 
  7.   } 
  8.   let length = 0 
  9.   let head = null  // 用來存儲頭部元素的引用 
  10.   let tail = null  // 用來存儲尾部元素的引用 
  11.  
  12.   // 尾部添加元素 
  13.   this.append = (el) => { 
  14.     let node = new Node(el) 
  15.     if(!head) { 
  16.       head = node 
  17.     }else { 
  18.       tail.next = node; 
  19.       node.previous = tail; 
  20.     } 
  21.     tail = node; 
  22.     length++ 
  23.   }; 
  24.   // 插入元素 
  25.   this.insert = (pos, el) => { 
  26.     if(pos >=0 && pos < length) { 
  27.       let node = new Node(el); 
  28.       if(pos === length - 1) { 
  29.         // 在尾部插入 
  30.         node.previous = tail.previous; 
  31.         node.next = tail; 
  32.         tail.previous = node; 
  33.         length++; 
  34.         return true 
  35.       } 
  36.       let current = head, 
  37.           i = 0; 
  38.       while(i < pos) { 
  39.         current = current.next; 
  40.         i++ 
  41.       } 
  42.       node.next = current; 
  43.       node.previous = current.previous; 
  44.       current.previous.next = node; 
  45.       current.previous = node; 
  46.       length ++; 
  47.       return true     
  48.     }else { 
  49.       throw new RangeError(`插入范圍有誤`) 
  50.     } 
  51.   }; 
  52.   // 移除指定位置的元素 
  53.   this.removeAt = (pos) => { 
  54.     // 檢測邊界條件 
  55.     if(pos < 0 || pos >= length) { 
  56.       throw new RangeError(`刪除范圍有誤`) 
  57.     }else { 
  58.       if(length) { 
  59.         if(pos === length - 1) { 
  60.           // 如果刪除節點位置為尾節點,直接刪除,節省查找時間 
  61.           let previous = tail.previous; 
  62.           previous.next = null; 
  63.           length --; 
  64.           return tail.el 
  65.         }else { 
  66.           let current = head, 
  67.               previous = null, 
  68.               next = null, 
  69.               i = 0; 
  70.           while(i < pos) { 
  71.             current = current.next 
  72.             i++ 
  73.           } 
  74.           previous = current.previous; 
  75.           next = current.next; 
  76.           previous.next = next; 
  77.           length --; 
  78.           return current.el 
  79.         } 
  80.       }else { 
  81.         return null 
  82.       } 
  83.     } 
  84.   }; 
  85.   // 移除指定節點 
  86.   this.remove = (el) => { 
  87.     let idx = this.indexOf(el); 
  88.     this.removeAt(idx); 
  89.   }; 
  90.   // 查詢指定位置的鏈表元素 
  91.   this.get = (index) => { 
  92.     if(index < 0 || index >= length) { 
  93.       return undefined 
  94.     }else { 
  95.       if(length) { 
  96.         if(index === length - 1) { 
  97.           return tail.el 
  98.         } 
  99.         let current = head, 
  100.             i = 0; 
  101.         while(i < index) { 
  102.           current = current.next 
  103.           i++ 
  104.         } 
  105.         return current.el 
  106.       }else { 
  107.         return undefined 
  108.       } 
  109.     } 
  110.   } 
  111.   // 查詢節點所在位置 
  112.   this.indexOf = (el) => { 
  113.     let idx = -1, 
  114.         current = head, 
  115.         curIdx = -1; 
  116.     while(current) { 
  117.       idx++ 
  118.       if(current.el === el) { 
  119.         curIdx = idx; 
  120.         break; 
  121.       } 
  122.       current = current.next; 
  123.     } 
  124.     return curIdx 
  125.   }; 
  126.   // 判斷鏈表是否為空 
  127.   this.isEmpty = () => { 
  128.     return length === 0 
  129.   }; 
  130.   // 返回鏈表長度 
  131.   this.size = () => { 
  132.     return length 
  133.   }; 
  134.   // 將鏈表轉化為數組返回 
  135.   this.toArray = () => { 
  136.     let current = head, 
  137.         results = []; 
  138.     while(current) { 
  139.       results.push(current.el); 
  140.       current = current.next; 
  141.     } 
  142.     return results 
  143.   }; 
  144. } 

4.鏈表和數組的對比及優缺點

實現完鏈表之后我們會對鏈表有更深入的認知，接下來我們進一步分析鏈表的優缺點。筆者將從3個維度來帶大家分析鏈表的性能情況：

  • 插入刪除性能
  • 查詢性能
  • 內存占用

我們先看看插入和刪除的過程：

由上圖可以發現，鏈表的插入、刪除數據效率非常高，只需要考慮相鄰結點的指針變化，因為不需要移動其他節點，時間復雜度是 O(1)。

再來看看查詢過程：

我們對鏈表進行每一次查詢時，都需要從鏈表的頭部開始找起，一步步遍歷到目標節點，這個過程效率是非常低的，時間復雜度是 O(n)。這方面我們使用數組的話效率會更高一點。

我們再看看內存占用。鏈表的內存消耗比較大，因為每個結點除了要存儲數據本身，還要儲存前后結點的地址。但是好處是可以動態分配內存。

另一方面，對于數組來說，也存在一些缺點，比如數組必須占用整塊、連續的內存空間，如果聲明的數組數據量過大，可能會導致“內存不足”。其次就是數組一旦需要擴容，會重新申請連續的內存空間，并且需要把上一次的數組數據全部copy到新的內存空間中。

綜上所述，當我們的數據存在頻繁的插入刪除操作時，我們可以采用鏈表結構來存儲我們的數據，如果涉及到頻繁查找的操作，我們可以采用數組來處理。實際工作中很多底層框架的封裝都是采用組合模式進行設計，一般純粹采用某種數據結構的比較少，所以具體還是要根據所處環境進行適當的方案設計。

 

責任編輯：姜華 來源： 趣談前端
前端開發技術熱點
相關推薦

2024-11-04 06:00:00

redis雙向鏈表

2010-02-06 09:46:46

C++單向鏈表

2024-11-22 15:00:00

開源Redis鏈表

2013-12-18 13:30:19

Linux運維Linux學習Linux入門

2025-04-18 00:00:00

MCPSSEHTTP

2021-08-15 22:52:30

前端H5拼圖

2020-09-24 11:46:03

Promise

2011-02-28 18:19:40

無線

2013-07-01 15:06:04

2015-10-12 16:37:39

前端編碼雙向編譯

2021-02-19 23:07:02

Vue綁定組件

2023-01-07 08:09:41

零代碼Dooring組件

2024-08-28 08:09:13

contextmetrics類型

2023-11-07 14:30:28

Python開發

2022-12-26 00:51:33

雙向鏈表二叉搜索樹

2022-02-13 23:00:48

前端微前端qiankun

2020-10-18 17:09:14

前端開發技術

2020-05-20 22:37:42

HTTPSSSL雙向驗證

2024-05-31 08:53:56

2023-04-18 08:27:16

日志級別日志包
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 一区二区三区国产好 | 超碰综合 | 日韩av在线免费 | www.一区二区三区 | 中文字幕国产视频 | 久久久久久综合 | 亚洲国产欧美国产综合一区 | 午夜伦理影院 | 国产一区二区久久 | 国产一区二区黑人欧美xxxx | 国产精品一区二区三级 | 精品国产精品国产偷麻豆 | 美女视频一区 | 欧美成人一区二免费视频软件 | 91在线一区 | 欧美8一10sex性hd | 亚洲一区二区三区四区av | 国产一区二区在线免费观看 | 天天干天天操天天爽 | 91视频18| 日韩一区二区三区精品 | 欧美国产日韩一区二区三区 | av在线免费观看网站 | 欧美精品91 | 放个毛片看看 | 日韩成人免费av | 亚洲av毛片 | 日本精品999| 欧美日韩在线精品 | 91麻豆精品国产91久久久更新资源速度超快 | 久久久久久蜜桃一区二区 | 国产一区二区三区亚洲 | 免费毛片网 | 国产在视频一区二区三区吞精 | 亚洲高清一区二区三区 | 欧美 日韩 在线播放 | 999精品网| 国产精品国产精品国产专区不片 | 国产视频1区2区 | 91极品视频 | 国偷自产av一区二区三区 |