JS版資料結構第三篇(連結串列)

頭指標head和終端結點

• 單連結串列中每個結點的儲存地址是存放在其前趨結點next域(即它前一個節點的next指標)中
• 而開始結點無前趨，故應設頭指標head指向開始結點。
• 連結串列由頭指標唯一確定，單連結串列可以用頭指標的名字來命名。
• 終端結點無後繼，故終端結點的指標域為空，即NULL。

你就可以根據它獲取到連結串列中的任何一個元素了,將結點元素'連線'在一起就稱之為連結串列,

設計單連結串列的實現。單連結串列中的節點應該具有兩個屬性：val 和 next。val 是當前節點的值，next 是指向下一個節點的指標/引用。假設連結串列中的所有節點都是 0-index 的。

在連結串列類中實現這些功能：

• get(index)：獲取連結串列中第 index 個節點的值。如果索引無效，則返回-1。
• addAtHead(val)：在連結串列的第一個元素之前新增一個值為 val 的節點。插入後，新節點將成為連結串列的第一個節點。
• addAtTail(val)：將值為 val 的節點追加到連結串列的最後一個元素。
• addAtIndex(index,val)：在連結串列中的第 index 個節點之前新增值為 val 的節點。如果 index 等於連結串列的長度，則該節點將附加到連結串列的末尾。如果 index 大於連結串列長度，則不會插入節點。
• deleteAtIndex(index)：如果索引 index 有效，則刪除連結串列中的第 index 個節點。

示例:

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //連結串列變為1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //現在連結串列是1-> 3
linkedList.get(1);            //返回3複製程式碼

題目要求我們設計一個基本的列表並實現增刪改查等基礎功能，在對單連結串列有一個基本的瞭解後應該很容易讀懂題目,我們直接開始解題

首先我們需要建立一個連結串列類(建構函式),這個也就是我們要設計的連結串列,它包含了：

• _length 用於表示連結串列中的節點數量

• head 分配一個節點作為連結串列的頭

• get(index) 根據索引查詢節點對應的值

• addAtHead(value) 向連結串列中第一個元素前新增一個節點

• addAtTail(value) 向連結串列中最後元素後新增一個節點
  

• addAtIndex(index,val) 在連結串列中的第 index 個節點之前新增值為 val 的節點

• deleteAtIndex(index) 刪除指定位置的節點

// 連結串列類
class MyLinkedList{    
    constructor(){
        // 頭指標初始為空
        this.head = null
        // 長度初始為0
        this._length = 0
    }
    get (index) {

    }    
    addAtHead (val) {

    }
    addAtTail (val) {

    }    
    addAtIndex (index, val) {

    }    
    deleteAtIndex (index) {

    }}複製程式碼

然後我們需要一個節點類(建構函式),用來儲存每個節點的value以及next屬性

• data 儲存資料

• next 指向連結串列中下一個節點的指標

// 節點類
class Node(value) {
    // 例項化時賦值
    this.val = value
    // next指標初始為null
    this.next = null
}複製程式碼

addAtHead(val){
    let oldHead = this.head
    this.head = new Node(val)
    this.head.next = oldHead
    this._length++
}複製程式碼

1. 以val值例項化新的node節點
2. 根據頭指標head遍歷到連結串列中最後一個元素
3. 將最後一個元素的next指標指向新的node節點

addAtTail (val) {
    let node = new Node(val)
    // 用一個變數儲存連結串列最後一個節點 初始值為頭指標
    let last = this.head
    // 遍歷找到最後一個節點
    while(last && last.next){
        last = last.next
    }
    // 如果非空連結串列
    if(last){
        // 將最後一個節點指向插入的節點
        last.next = node
    }else{
        // 若為空連結串列 將頭指標指向新插入節點
        this.head = node
    }
    this._length++
}複製程式碼

1. 宣告一個變數currentIndex記錄遍歷的次數,初始為0
2. 根據頭指標head的next指標遍歷連結串列,每查詢一次next,將currentIndex加1
3. 直到currentIndex與要查詢的index相等

get(index){
    // 記錄遍歷次數 初始為0
    let currentIndex = 0
    // 記錄遍歷到的節點 初始為head
    let cur = thi.head
    // 根據題意, 索引無效則返回 -1
    if(index < 0 || this._length < index + 1){
        return -1
    }
    // 直到查詢到索引為index的元素為止
    while (cur){
        if(currentIndex = index){
            return cur.val
        }
    }
    cur = cur.next
    currentIndex++
}複製程式碼

• 方法4：addAtIndex(index,val)

程式碼如下：

addAtIndex(index, val){
    //  若索引在0位之前 直接呼叫addAtHead方法
    if(index <= 0){
        return this.addAtHead(val)
    }
    // 如果index值大於0
    if(index >= 0 && index <= this._length){
        // 以val值例項化新結點
        let node = new Node(val)
        // 記錄當前遍歷的結點,初始為head    
        let cur = this.head
        // 記錄遍歷次數
        let currentIndex = 0
        // 記錄當前遍歷結點的next指標
        let next
        while(cur){
            if(currentIndex === index - 1）{
                // 此時cur為要插入結點的前方結點
                // 用next儲存插入元素前方結點的原next指標
                next = cur.next
                cur.next = node
                node.next = next
                this._length++
                break
             }
             cur = cur.next
             currentIndex++
        }   
    }
}複製程式碼

• 方法5：deleteAtIndex(index)

deleteIndex(index){
    // 若索引有效
    if(index >=0 && index <= this._length -1){
        let cur = this.head
        // 若刪除索引為0的元素,只需將head指標向下移動一位,不需要考慮刪除元素之前結點的指標
        if(index === 0){
            this.head = cur.next
            this._length--
        }else{
            // 若刪除索引非0
            let currentIndex = 0
            let next
            while(cur){
                if(currentIndex === index-1){
                    // 此時cur為要刪除元素的前一個結點
                    next = cur.next.next
                    // 先將刪除元素清空 避免記憶體洩漏
                    cur.next = null
                    cur.next = next
                    this._length--
                }
                cur = cur.next
                currentIndex++
            }
        }
    }
}複製程式碼

這樣我們就實現了一個完整的實現增刪改查功能的單連結串列了,完整程式碼如下:

class Node {
  constructor (val) {
    this.value = val
    this.next = null
  }
}
class MyLinkedList {
  constructor () {
    this._length = 0
    this.head = null
  }
  addAtHead (val) {
    let originHead = this.head
    this.head = new Node(val)
    this.head.next = originHead
    this._length++
  }
  addAtTail (val) {
    let last = this.head
    let node = new Node(val)
    while (last && last.next) {
      last = last.next
    }
    if (last) {
      last.next = node
    } else {
      this.head = node
    }
    this._length++
  }
  get (index) {
    let currentIndex = 0
    let cur = this.head
    if (index < 0 || this._length < index + 1) {
      return -1
    }
    while (cur) {
      if (currentIndex === index) {
        return cur.value
      }
      cur = cur.next
      currentIndex++
    }
  }
  // 特定位置插入
  addAtIndex(index, val){    //  若索引在0位之前 直接呼叫addAtHead方法
    if(index <= 0){
        return this.addAtHead(val)
    }
    // 如果index值大於0
    if(index >= 0 && index <= this._length){
        // 以val值例項化新結點
        let node = new Node(val)
        // 記錄當前遍歷的結點,初始為head    
        let cur = this.head
        // 記錄遍歷次數
        let currentIndex = 0
        // 記錄當前遍歷結點的next指標
        let next
        while(cur){
            if(currentIndex === index - 1）{
                // 此時cur為要插入結點的前方結點
                // 用next儲存插入元素前方結點的原next指標
                next = cur.next
                cur.next = node
                node.next = next
                this._length++
                break
             }
             cur = cur.next
             currentIndex++
        }   
    }
}  // 按索引刪除
  deleteAtIndex (index) {
    if (index >= 0 && index <= this._length - 1) {
      let cur = this.head
      // 如果刪第0位
      if (index === 0) {
        this.head = cur.next
        this._length--
      } else {
        let currentIndex = 0
        let next
        while (cur) {
          if (currentIndex === index - 1) {
          // 此時cur是被刪除元素的前一位
            next = cur.next.next
            // 先將刪除元素清空 避免記憶體洩漏
            cur.next = null
            cur.next = next
            this._length--
          }
          cur = cur.next
          currentIndex++
        }
      }
    }
  }
}
複製程式碼

輸入：head = [3,2,0,-4], pos = 1
輸出：true
解釋：連結串列中有一個環，其尾部連線到第二個節點。

複製程式碼