轉載請注明出處：數據結構——Golang實現雙向鏈表
Golang
1. 雙向鏈表
雙向鏈表也叫雙鏈表，是鏈表的一種，它的每個數據結點中都有兩個指針，分別指向直接后繼和直接前驅。所以，從雙向鏈表中的任意一個結點開始，都可以很方便地訪問它的前驅結點和后繼結點。
結構如下圖：
image.png
2. Golang 實現
2.1. 相關結構體
首先需要先定義一下鏈表相關的結構，DoubleObject用于每個節點的數據，為interface{}結構，DoubleNode為鏈表中的節點，DoubleList雙鏈表，為了多協程讀寫安全，所以在鏈表中加了讀寫鎖。
具體定義如下：
// 節點數據
type DoubleObject interface{}
// 雙鏈表節點
type DoubleNode struct {
Data DoubleObject
Prev *DoubleNode
Next *DoubleNode
}
// 雙鏈表
type DoubleList struct{
mutex *sync.RWMutex
Size uint
Head *DoubleNode
Tail *DoubleNode
}
2.2. 鏈表初始化
定義完結構，接下來就需要對雙鏈表進行初始化了。代碼如下：
// 雙鏈表初始化
func (list *DoubleList)Init() {
list.mutex = new(sync.RWMutex)
list.Size = 0
list.Head = nil
list.Tail = nil
}
2.3. 查詢節點
根據指定的位置索引，查詢出節點內容。
// Get 獲取指定位置的節點
func (list *DoubleList)Get(index uint) *DoubleNode {
if list.Size == 0 || index > list.Size - 1 {
return nil
}
if index == 0{
return list.Head
}
node := list.Head
var i uint
for i = 1; i <= index; i ++{
node = node.Next
}
return node
}
2.4. 新增節點
鏈表節點的新增分為兩種，一種是在鏈表后面追加節點，該方式，我們稱為append；另外一種方式是在指定位置插入節點，我們叫做insert。
// Append 向雙鏈表后面追加節點
func (list *DoubleList)Append(node *DoubleNode) bool {
if node == nil{
return false
}
list.mutex.Lock()
defer list.mutex.Unlock()
if list.Size == 0 {
list.Head = node
list.Tail = node
node.Next = nil
node.Prev = nil
} else {
node.Prev = list.Tail
node.Next = nil
list.Tail.Next = node
list.Tail = node
}
list.Size++
return true
}
// Insert 向雙鏈表指定位置插入節點
func (list *DoubleList)Insert(index uint, node *DoubleNode) bool {
if index > list.Size || node == nil{
return false
}
if index == list.Size{
return list.Append(node)
}
list.mutex.Lock()
defer list.mutex.Unlock()
if index == 0{
node.Next = list.Head
list.Head = node
list.Head.Prev = nil
list.Size++
return true
}
nextNode := list.Get(index)
node.Prev = nextNode.Prev
node.Next = nextNode
nextNode.Prev.Next = node
nextNode.Prev = node
list.Size++
return true
}
2.5. 刪除節點
有了新增功能自然就少不了刪除，此外，刪除節點時，如果指定的位置是鏈表的頭部或尾部，都需要特殊處理下。看代碼：
// Delete 刪除指定位置的節點
func (list *DoubleList) Delete (index uint) bool {
if index > list.Size - 1 {
return false
}
list.mutex.Lock()
defer list.mutex.Unlock()
if index == 0 {
if list.Size == 1{
list.Head = nil
list.Tail = nil
} else {
list.Head.Next.Prev = nil
list.Head = list.Head.Next
}
list.Size--
return true
}
if index == list.Size - 1{
list.Tail.Prev.Next = nil
list.Tail = list.Tail.Prev
list.Size--
return true
}
node := list.Get(index)
node.Prev.Next = node.Next
node.Next.Prev = node.Prev
list.Size--
return true
}
2.6. 打印鏈表
最后，我們增加一個打印鏈表的功能，方便我們看整個鏈表的內容，這里增加了兩種打印方法，一個是從頭到尾打印，另一個是從尾到頭打印：
// Display 打印雙鏈表信息
func (list *DoubleList)Display(){
if list == nil || list.Size == 0 {
fmt.Println("this double list is nil or empty")
return
}
list.mutex.RLock()
defer list.mutex.RUnlock()
fmt.Printf("this double list size is %d \n", list.Size)
ptr := list.Head
for ptr != nil {
fmt.Printf("data is %v\n", ptr.Data)
ptr = ptr.Next
}
}
// Reverse 倒序打印雙鏈表信息
func (list *DoubleList)Reverse(){
if list == nil || list.Size == 0 {
fmt.Println("this double list is nil or empty")
return
}
list.mutex.RLock()
defer list.mutex.RUnlock()
fmt.Printf("this double list size is %d \n", list.Size)
ptr := list.Tail
for ptr != nil {
fmt.Printf("data is %v\n", ptr.Data)
ptr = ptr.Prev
}
}
3. 源碼
完
轉載請注明出處: 數據結構——Golang實現雙向鏈表
