2. 程式人生 > 其它 >【Go資料結構】連結串列 Linked List

【Go資料結構】連結串列 Linked List

阿新 • • 發佈：2022-05-18

連結串列 Linked List

元素在記憶體中不是連續存放。
元素間通過指向指標聯絡在一起，訪問元素必須從第一個元素開始遍歷查詢。

  • 優點：插入、刪除元素只需改變指標，快 O(1)
  • 缺點：隨機訪問慢 O(N)
  • 場景：經常插入、刪除元素

分類

  • 單向連結串列：節點僅指向下一節點，最後一個節點指向 nil
  • 雙向連結串列：每個節點有 2 個指標 pre 和 next，最後一個節點的 next 指向 nil
  • 迴圈連結串列：單鏈表 + 最後一個節點指向第一個節點

時間複雜度

  • 查詢：O(N)
  • 插入、移除：O(1)

實現細節

不帶頭結點：

帶頭結點：

頭指標：

  1. 頭指標是指向第一個結點的指標，若是連結串列中只有頭結點，則是指向頭結點的指標
  2. 頭指標具有標識作用，所以常常以頭指標冠以連結串列的名字（指標變數名）
  3. 無論連結串列是否為空，頭結點均不為空
  4. 頭指標是連結串列必要元素

頭結點：

  1. 頭結點是為了操作統一和方便而設立的，放在第一個元素結點之前，其資料域一般無意義（也可以存放表長度）
  2. 有了頭結點，對第一個元素結點的插入，刪除，其操作和其他結點操作統一了
  3. 頭結點不一定是連結串列的必要元素

Go實現

package list

const (
   MAXSIZE = 20
)

type ElemType int //元素型別

const EmptyElement = 0 //空值

/**
線性表的抽象資料型別定義

定義：由零個（空表）或多個數據元素組成的序列

ADT:
    線性表List
Data:
    線性表的資料物件集合為{a1,a2,...,an},每個元素型別為DataType。除了第一個無前驅，最後一個無後繼，
    其他每個元素都有一個位元組前驅和直接後繼結點。資料元素間關係一對一。
Operation:
    InitList(*L);//初始線性表,建立空表
    ClearList(*L);//清空線性表資料
    ListEmpty(L);//判斷列表是否為空
    ListLength(L);//獲取線性表的長度

    GetElem(L,i,* e);//獲取指定位置的元素，返回在指標元素中
    LocateElem(L,e);//查詢元素線上性表中的位置
    ListInsert(*L,i,e);//向線性表中指定位置插入元素
    ListDelete(*L, i, *e);//刪除指定位置處的元素
*/

//注意線性表中的位置不是按照陣列一樣從0開始，而是按照我們正常習慣1開始的

type MyList interface {
   //四個基本操作，初始，清空，判斷是否為空，獲取長度
   InitList()
   ClearList()
   ListEmpty() bool
   ListLength() int

   //四個元素操作，插入，刪除，兩種查詢
   GetElem(index int, e *ElemType) bool
   LocateElem(value ElemType) int
   ListInsert(index int, value ElemType) bool
   ListDelete(index int, e *ElemType) bool

   Echo()
   //Test()
}

 
package my_chain

import (
   "fmt"
   "my_go/dataStructure/list"
)

//鏈式儲存
//可以用頭指標用來儲存長度 也就是第0個
//但是這個有個弊端就是當儲存的不是int型別時會有問題
//所有還是新增一個欄位表示長度
//為了保持從1開始，頭指標還是不放東西
type LinkList struct {
   Head   *Node
   Length int
}

type Node struct {
   Data list.ElemType
   Next *Node
}

//初始化列表
func (l *LinkList) InitList() {
   l.Head = new(Node)
   l.Length = 0
}

//清空列表（不會清除頭結點）
func (l *LinkList) ClearList() {
   p := new(Node)
   q := l.Head //q指向第一個結點

   //釋放記憶體，其實go可以不需要這個迴圈
   for q != nil {
      p = q
      q = p.Next
      p = nil
   }
   l.Head.Next = nil
   l.Length = 0
}

//判斷是否為空
func (l *LinkList) ListEmpty() bool {
   if l.Length == 0 {
      return true
   }
   return false
}

//獲取長度
func (l *LinkList) ListLength() int {
   return l.Length
}

//查
func (l *LinkList) GetElem(index int, e *list.ElemType) bool {
   if l.Length == 0 {
      fmt.Println("獲取失敗，佇列為空")
      return false
   }
   if index < 1 || index > l.Length {
      fmt.Println("獲取失敗，位置錯誤")
      return false
   }

   j := 1
   q := l.Head.Next
   for q != nil && j < index {
      q = q.Next
      j++
   }

   //有了這一步其實開頭的判斷可以去掉
   if q == nil || j > index {
      return false
   }

   *e = q.Data
   return true
}

//按照元素進行查詢，獲取索引
func (l *LinkList) LocateElem(value list.ElemType) int {

   if l.Length == 0 {
      fmt.Println("獲取失敗，佇列為空")
      return 0
   }

   j := 0
   q := l.Head.Next
   for q != nil {
      j++
      if q.Data == value {
         break
      }
      q = q.Next
   }

   if j >= list.MAXSIZE {
      return 0
   }

   return j
}

//按照索引進行插入資料
func (l *LinkList) ListInsert(index int, value list.ElemType) bool {

   if l.Length == list.MAXSIZE { //滿了
      fmt.Println("插入失敗，佇列已滿")
      return false
   }
   if index < 1 || index > l.Length+1 {
      fmt.Println(fmt.Sprintf("插入失敗，位置錯誤:%d", index))
      return false
   }

   front := l.Head

   //找到插入位置的前驅
   for j := 1; j < index; j++ {
      front = front.Next
   }

   //新建節點，加入連結串列
   n := new(Node)
   n.Next = front.Next
   n.Data = value
   front.Next = n

   l.Length++

   return true
}

//刪
func (l *LinkList) ListDelete(index int, e *list.ElemType) bool {
   if l.Length == 0 {
      fmt.Println("獲取失敗，佇列為空")
      return false
   }
   if index < 1 || index > l.Length {
      fmt.Println("獲取失敗，位置錯誤")
      return false
   }

   j := 1
   front := l.Head

   //找到索引的直接前驅
   for front.Next != nil && j < index {
      front = front.Next
      j++
   }

   if front.Next == nil || j > index {
      return false
   }

   //開始刪除
   tmp := front.Next     //記錄要刪除的
   *e = tmp.Data         //返回刪除節點的資料
   front.Next = tmp.Next //前驅節點直接指向後繼節點，就跳過了要刪除的節點
   //free(tmp)

   l.Length--

   return true
}

//輸出
func (l *LinkList) Echo() {
   //遍歷的寫法
   curItem := l.Head.Next
   for i := 0; i < l.Length; i++ {
      fmt.Print(curItem.Data, " ")
      curItem = curItem.Next
   }
   fmt.Println()
}

測試

package my_chain

import (
   "fmt"
   "my_go/dataStructure/list"
   "testing"
)

func Test(t *testing.T) {
   fmt.Println("測試開始")

   my_list := new(LinkList)
   my_list.InitList()

   for i := 1; i <= 10; i++ {
      my_list.ListInsert(i, list.ElemType(i*i+1))
      my_list.Echo()
   }

   fmt.Println("第5個這裡插入256")
   my_list.ListInsert(5, 256)
   my_list.Echo()
   my_list.ListInsert(199, 99)

   var e list.ElemType

   my_list.ListDelete(1, &e)
   fmt.Println("刪除頭元素:", e)
   my_list.Echo()

   my_list.ListDelete(my_list.ListLength(), &e)
   fmt.Println("刪除尾元素:", e)
   my_list.Echo()

   my_list.GetElem(6, &e)
   fmt.Println("獲取第6個:", e)

   fmt.Println("256的位置:", my_list.LocateElem(256))

   fmt.Println("長度：", my_list.ListLength())

   fmt.Println("開始清空")
   my_list.ClearList()
   if my_list.ListEmpty() {
      fmt.Println("已清空")
      my_list.Echo()
   }

   fmt.Println("測試完成")
}

相關推薦

【Go資料結構】連結串列 Linked List

連結串列 Linked List 元素在記憶體中不是連續存放。 元素間通過指向指標聯絡在一起，訪問元素必須從第一個元素開始遍歷查詢。

【PHP資料結構】連結串列的相關邏輯操作

連結串列的操作相對順序表（陣列）來說就複雜了許多。因為 PHP 確實已經為我們解決了很多陣列操作上的問題，所以我們可以很方便的運算元組，也就不用為陣列定義很多的邏輯操作。比如在 C 中，陣列是有長度限制的，而

【Go資料結構】靜態連結串列 Static List

和連結串列一樣，只是針對沒有指標的語言。新增一個數據儲存下一個元素的遊標。

【資料結構】連結串列的逆置（圖文）

前言 輸入的是一條帶有頭結點的連結串列L 故頭結點為L，第一個節點為L->next.

【PHP資料結構】線性表？順序表？連結串列？別再傻傻分不清楚

遵從所有教材以及各類資料結構相關的書書籍，我們先從線性表開始入門。今天這篇文章更偏概念，是關於有線性表的一個知識點的彙總。

【資料結構篇】連結串列（c語言）

title: 【資料結構篇】連結串列 date: 2022-02-15 10:32:54 tags: - 資料結構 - 連結串列 - C語言

iOS中用到的資料結構_連結串列

關鍵詞：連結串列、AutoreleasePool、NSNotification、連結串列熱門問題及解法 推薦大家leetcode的探索裡的連結串列--看的再多不如自己練習下

memcached中的經典資料結構hash連結串列和LRU刪除策略的應用

hash連結串列是memcached核心的資料結構了，hash表用於快速讀取、寫入快取資料（item結構），連結串列用於實現lru策略，lru用於記憶體不足時的兜底策略，有效防止了記憶體不足時造成宕機

NET 資料結構-單連結串列

概念介紹： 單連結串列是一種鏈式存取的資料結構，用一組地址任意的儲存單元存放線性表中的資料元素。

資料結構雙向連結串列 DoublyLinkedList

package datastructures.linked; import java.util.Iterator; /** * @author warriorg */ public class DoublyLinkedList<T> implements Iterable<T> {

【Java資料結構】迴圈佇列的陣列實現

先上一個初級佇列的陣列實現，缺點是陣列不能複用，沒有可用性 public class ArrayQueue {

【Java資料結構】帶頭節點單鏈表的反轉，從尾到頭輸出，輸出倒數第k個節點

Java單鏈表的三個面試題： 1、將單鏈表反轉 2、從尾到頭輸出單鏈表 3、輸出單鏈表的倒數第k個節點

【Java資料結構】中綴表示式轉字尾表示式，字尾表示式的計算（多位數）

中綴表示式轉字尾表示式，字尾表示式的計算（多位數） 中綴表示式轉字尾表示式思路

資料結構003_連結串列

連結串列內容我打算就寫在這一篇裡。包括單鏈表，雙向連結串列，單向及雙向環形連結串列，josephu問題。

C#資料結構-靜態連結串列

對於雙向連結串列中的節點，都包括一個向前、向後的屬性器用於指向前後兩個節點，對於引用型別，物件儲存的是指向記憶體片段的記憶體指標，那麼我們可以將其簡化看作向前向後的兩個指標。

C語言資料結構迴圈連結串列（2）

迴圈連結串列的特點如何判斷一個迴圈連結串列是否為空表？ 就是通過判斷rear是否等於rear->next

資料結構-雙向連結串列

資料結構-雙向連結串列 為什麼要有雙向連結串列？ 單向連結串列的缺點分析:

【基礎資料結構】 學習筆記

資料結構是組織資料的結構，用來方便我們的操作。 陣列是一種簡單的資料結構（順序儲存結構的線性表）。

資料結構 ② ——陣列連結串列及部分操作

　　陣列是我們最常用的線性結構之一，在陣列中，我們使用的操作通常是增刪查改。

資料結構/PTA-連結串列逆置-另類堆疊/函式/連結串列

連結串列逆置 本題要求實現一個函式，將給定單向連結串列逆置，即表頭置為表尾，表尾置為表頭。連結串列結點定義如下：