2. 程式人生 > >js資料結構-連結串列

js資料結構-連結串列

阿新 • • 發佈：2019-01-06

連結串列和陣列

大家都用過js中的陣列，陣列其實是一種線性表的順序儲存結構，它的特點是用一組地址連續的儲存單元依次儲存資料元素。而它的缺點也正是其特點而造成，比如對陣列做刪除或者插入的時候，可能需要移動大量的元素。

這裡大致模擬一下陣列的插入操作：


    function insert(arr, index, data) {
      for (let i = arr.length; i >index; i--) {
        arr[i] = arr[i - 1];
      }
      arr[index] = data;
    }

從上面的程式碼可以看出陣列的插入以及刪除都有可能會是一個O(n)的操作。從而就引出了連結串列這種資料結構，連結串列不要求邏輯上相鄰的元素在物理位置上也相鄰，因此它沒有順序儲存結構所具有的缺點，當然它也失去了陣列在一塊連續空間內隨機存取的優點。

單向連結串列

在這裡插入圖片描述

單向連結串列的特點：

  • 用一組任意的記憶體空間去儲存資料元素（這裡的記憶體空間可以是連續的，也可以是不連續的）
  • 每個節點(node)都由資料本身和一個指向後續節點的指標組成
  • 整個連結串列的存取必須從頭指標開始，頭指標指向第一個節點
  • 最後一個節點的指標指向空（NULL）

連結串列中的幾個主要操作

  • 建立節點
  • 插入節點
  • 搜尋/遍歷節點
  • 刪除節點
  • 合併

初始化節點

  • 指標指向空
  • 儲存資料

    class Node {
        constructor(key) {
            this.next = null;
            this.key = key;
        }
    }

初始化單向連結串列

  • 每個連結串列都有一個頭指標，指向第一個節點，沒節點則指向NULL

    class List {
        constructor() {
            this.head = null;
        }
    }

建立節點


    static createNode(key) {
        return new createNode(key);
    }

這裡說明一下，這一塊我是向外暴露了一個靜態方法來建立節點，而並非直接把它封裝進插入操作裡去，因為我感覺這樣的邏輯會更加正確一些。 從建立一個連結串列 -> 建立一個節點 -> 將節點插入進連結串列中。可能你會遇到一些文章介紹的方式是直接將一個數據作為引數去呼叫insert操作，在insert內部做了一個建立節點。

插入節點（插入到頭節點之後）

插入操作只需要去調整節點的指標即可,兩種情況：

  • head沒有指向任何節點，說明當前插入的節點是第一個

    • head指向新節點
    • 新節點的指標指向NULL

  • head有指向的節點

    • head指向新的節點
    • 新節點的指標指向原本head所指向的節點

    insert(node) {
        // 如果head有指向的節點
        if(this.head){
           node.next = this.head;
        }else {
           node.next = null;
        }
        this.head = node;
    }

搜尋節點

  • 從head開始查詢
  • 找到節點中的key等於想要查詢的key的時候，返回該節點

    find(key) {
        let node = this.head;
        while(node !== null && node.key !== key){
            node = node.next;
        }
        return node;
    }

刪除節點

這裡分三種情況：

  • 所要刪除的節點剛好是第一個，也就是head指向的節點

    • 將head指向所要刪除節點的下一個節點(node.next)

  • 要刪除的節點為最後一個節點

    • 尋找到所要刪除節點的上一個節點(prevNode)
    • 將prevNode中的指標指向NULL

  • 在列表中間刪除某個節點

    • 尋找到所要刪除節點的上一個節點(prevNode)
    • 將prevNode中的指標指向當前要刪除的這個節點的下一個節點

    delete(node) {
        // 第一種情況
        if(node === this.head){
            this.head = node.next;
            return;
        }
        
        // 查詢所要刪除節點的上一個節點
        let prevNode = this.head;
        while (prevNode.next !== node) {
            prevNode = prevNode.next;
        }
        
        // 第二種情況
        if(node.next === null) {
            prevNode.next = null;
        }
        
        // 第三種情況
        if(node.next) {
            prevNode.next = node.next;
        }
    }

單向連結串列整體的程式碼


class ListNode {
  constructor(key) {
    this.next = null;
    this.key = key;
  }
}

class List {
  constructor() {
    this.head = null;
    this.length = 0;
  }

  static createNode(key) {
    return new ListNode(key);
  }

  // 往頭部插入資料
  insert(node) {
    // 如果head後面有指向的節點
    if (this.head) {
      node.next = this.head;
    } else {
      node.next = null;
    }
    this.head = node;
    this.length++;
  }

  find(key) {
    let node = this.head;
    while (node !== null && node.key !== key) {
      node = node.next;
    }
    return node;
  }

  delete(node) {
    if (this.length === 0) {
      throw 'node is undefined';
    }

    if (node === this.head) {
      this.head = node.next;
      this.length--;
      return;
    }

    let prevNode = this.head;

    while (prevNode.next !== node) {
      prevNode = prevNode.next;
    }

    if (node.next === null) {
      prevNode.next = null;
    }
    if (node.next) {
      prevNode.next = node.next;
    }
    this.length--;
  }
}

雙向連結串列

如果你把上面介紹的單向列表都看明白了，那麼這裡介紹的雙向列表其實差不多。

在這裡插入圖片描述

在這裡插入圖片描述

從上面的圖可以很清楚的看到雙向連結串列和單向連結串列的區別。雙向連結串列多了一個指向上一個節點的指標。

初始化節點

  • 指向前一個節點的指標
  • 指向後一個節點的指標
  • 節點資料

    class ListNode {
        this.prev = null;
        this.next = null;
        this.key = key;
    }

初始化雙向連結串列

  • 頭指標指向NULL

    class List {
        constructor(){
            this.head = null;
        }
    }

建立節點


    static createNode(key){
        return new ListNode(key);
    }

插入節點（（插入到頭節點之後）

  • 看上圖中head後面的第一個節點可以知道，該節點的prev指向NULL
  • 節點的next指標指向後一個節點, 也就是當前頭指標所指向的那個節點
  • 如果head後有節點，那麼原本head後的節點的prev指向新插入的這個節點(因為是雙向的嘛)
  • 最後將head指向新的節點

    insert(node) {
        node.prev = null;
        node.next = this.head;
        if(this.head){
            this.head.prev = node;
        }
        this.head = node;
    }

搜尋節點

這裡和單向節點一樣，就直接貼程式碼了


  search(key) {
    let node = this.head;
    while (node !== null && node.key !== key) {
      node = node.next;
    }
    return node;
  }

刪除節點

和之前單向連結串列一樣，分三種情況去看：

  • 刪除的是第一個節點

    • head指向所要刪除節點的下一個節點
    • 下一個節點的prev指標指向所要刪除節點的上一個節點

  • 刪除的是中間的某個節點

    • 所要刪除的前一個節點的next指向所要刪除的下一個節點
    • 所要刪除的下一個節點的prev指向所要刪除的前一個節點

  • 刪除的是最後一個節點

    • 要刪除的節點的上一個節點的next指向null（也就是指向刪除節點的next所指的地址）

在這裡插入圖片描述


    delete(node) {
        const {prev,next} = node;
        delete node.prev;
        delete node.next;
        if(node === this.head){
            this.head = next;
        }
        if(next){
            next.prev = prev;
        }
        if(prev){
            prev.next = next;
        }
    }

雙向連結串列整體程式碼


    class ListNode {
  constructor(key) {
    // 指向前一個節點
    this.prev = null;
    // 指向後一個節點
    this.next = null;
    // 節點的資料(或者用於查詢的鍵)
    this.key = key;
  }
}

/**
 * 雙向連結串列
 */
class List {
  constructor() {
    this.head = null;
  }

  static createNode(key) {
    return new ListNode(key);
  }

  insert(node) {
    node.prev = null;
    node.next = this.head;
    if (this.head) {
      this.head.prev = node;
    }
    this.head = node;
  }

  search(key) {
    let node = this.head;
    while (node !== null && node.key !== key) {
      node = node.next;
    }
    return node;
  }

  delete(node) {
    const { prev, next } = node;
    delete node.prev;
    delete node.next;

    if (node === this.head) {
      this.head = next;
    }

    if (prev) {
      prev.next = next;
    }
    if (next) {
      next.prev = prev;
    }
  }
}

總結

這裡做一個小總結吧，可能有一部分人讀到這裡還不是特別的明白，我的建議是先好好看懂上面的單向連結串列。 其實只要你明白了連結串列的基礎概念，就是有一個head，然後在有好多的節點(Node)，然後用一個指標把他們串起來就好了，至於裡面的插入操作也好，刪除也好，其實都是在調整節點中指標的指向。

後續

後續可能還會是資料結構，可能是講二叉堆，也可能回過頭來講一些佇列和棧的思想在程式中的應用。歡迎大家指出文章的錯誤，如果有什麼寫作建議也可以提出。我會持續的去寫關於前端的一些技術文章，如果大家喜歡的話可以關注一下哈

來源：https://segmentfault.com/a/1190000017569816

相關推薦

js資料結構 -- 連結串列, 雙向連結串列，迴圈連結串列

陣列作為js常用的資料結構，存取元素都非常的方便，但是其內部的實現原理跟其他計算機語言對陣列的實現都是一樣的。 由於陣列在記憶體中的儲存是連續的，所以當在陣列的開頭或者中間插入元素時，內部都需要去移動其他元素的位置，這個移動元素的成本很高。 連結串列也是儲存有序的元素集合，但不同

js資料結構--連結串列

連結串列和陣列 大家都用過js中的陣列，陣列其實是一種線性表的順序儲存結構，它的特點是用一組地址連續的儲存單元依次儲存資料元素。而它的缺點也正是其特點而造成，比如對陣列做刪除或者插入的時候，可能需要移動大量的元素。 這裡大致模擬一下陣列的插入操作： insert(arr,

js資料結構-連結串列

連結串列和陣列 大家都用過js中的陣列，陣列其實是一種線性表的順序儲存結構，它的特點是用一組地址連續的儲存單元依次儲存資料元素。而它的缺點也正是其特點而造成，比如對陣列做刪除或者插入的時候，可能需要移動大量的元素。 這裡大致模擬一下陣列的插入操作： function i

js實現資料結構—連結串列

一、單鏈表建構函式 function LinkedList() { /** * 資料節點建構函式 * * @param {*} data */ function Node(data) {

資料結構連結串列題目1：查詢、插入、刪除基本操作 解析

1.連結串列的查詢插入刪除 有問題的程式碼： #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; ListNode

資料結構連結串列題目2：交換位置、3：合併

利用查詢、提取資料、插入、刪除、輸出等函式，順利搞定第二題 #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; List

Python資料結構-連結串列

1）概念：連結串列是一種物理儲存單元上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列結點（連結串列中每一個元素稱為結點）組成，結點可以在執行時動態生成。每個結點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域。 相比於線性表順序結

資料結構--連結串列

    定義         n個節點離散分配         彼此通過指標相連        &n

java中的資料結構——連結串列

連結串列 連結串列也是線性資料結構，與陣列相比，在記憶體分配、內部結構及資料插入和刪除的操作上均有不同。 連結串列用途廣泛，適用於許多通用的資料庫，也可以取代陣列，作為其他儲存結構的基礎。 在連結串列中，每個資料項都被包含在鏈節點中，一個鏈節點是某個類的物件，這個類叫做Link。因為一個

Redis底層資料結構--連結串列

這是普通的連結串列實現, 連結串列結點不直接持有資料, 而是通過void *指標來間接的指向資料. 其實現位於 src/adlist.h與src/adlist.c中, 關鍵定義如下: typedef struct listNode { struct listNode *prev

資料結構 - 連結串列

連結串列 　　之前講到的動態陣列、棧、佇列，底層都是依託靜態陣列，靠resize解決固定容量問題。而連結串列是一種真正的動態線性的資料結構。   　　*最簡單的動態資料結構 　　*更加深入理解引用 　　*更深入的理解遞迴 　　*輔組組成其他資料結構 　　 　　資料儲存在節點（Node

資料結構-連結串列-練習題1

題目 2.已知一個帶表頭結點的單鏈表，結點結構為data、link,假設該連結串列只給出了頭指標list。 在不改變連結串列的前提下，請設計一個儘可能高效的演算法，查詢連結串列中倒數第k個位置上的結點（k正為整數）。 若查詢成功，演算法輸出該結點的data域的值，並返回1

前端也需要了解的資料結構-連結串列

前言 最近被小夥伴問到連結串列是什麼,連結串列作為一種常見的資料結構,但是很多前端coder對此並不瞭解,寫下這篇文章,介紹下連結串列的js實現,不瞭解連結串列的同學也可以做個參考 單向連結串列 和陣列區別，地址離散。它在記憶體地址中可以離散的分配，由於它是離散的分配，所以他可以

資料結構---------連結串列

一、連結串列為什麼存在？       1）.陣列的缺陷                    無序列表：搜尋效能差，有序列表：插入效率低，並且兩個的刪除效率也很低，陣列在

資料結構-連結串列（java實現）

/** * 連結串列節點定義 * */ private class Node { private Object data; private Node next; public Node getNext() { return next;

資料結構—連結串列經典面試題

 連結串列面試題： 從尾到頭列印單鏈表 刪除一個無頭單鏈表的非尾節點（不能遍歷連結串列） 在無頭單鏈表的一個節點前插入一個節點（不能遍歷連結串列） 單鏈表實現約瑟夫環(JosephCircle) 逆置/反轉單鏈表 單鏈表排序（氣泡排序&快速排序） 合併

演算法導論---資料結構----連結串列篇

資料結構----連結串列 連結串列的每個元素都是一個物件x，x.key(鍵值),x.prev（上一個指標）, x.next（下一個指標）,x.head（表頭） 雙向連結串列：x.prev, x.next,x.head 單向連結串列：x.next，x.head 迴圈連結

資料結構——連結串列求兩集合的交集

#include <stdio.h> #include <malloc.h> typedef struct Node { int data; struct Node *next; }LNode,*LinkList; LNode *C

資料結構——連結串列（幾個拓展的做法）

#include <stdio.h>//注意放在c++中 #include <stdlib.h> #include <string.h> typedef struct as{ int date; struct

資料結構-連結串列

本章將討論另一種列表: 連結串列 . 解釋為什麼有時連結串列優於陣列, 還會實現一個基於物件的連結串列. 陣列的缺點 陣列不總是組織資料的最佳資料結構, 原因如下. 在很多程式語言中, 陣列的長度是固定的, 所以當陣列已被資料填滿時, 再要加入新的元素就會非常困難.