La liste doublement chaînée est une structure de données couramment utilisée qui nous permet d'effectuer des opérations d'insertion, de suppression ou de requête à n'importe quelle position de la liste chaînée dans une complexité temporelle O(1).
L'implémentation d'une liste doublement chaînée dans Golang nécessite l'utilisation de pointeurs, car tous les types dans Golang sont des types valeur et les données d'origine ne peuvent pas être modifiées directement. Grâce aux pointeurs, nous pouvons facilement modifier et transférer des valeurs, réalisant ainsi le fonctionnement de listes doublement chaînées.
Ce qui suit est une simple implémentation Golang d'une liste doublement chaînée :
package main
import "fmt"
type Node struct {
data int
previous *Node
next *Node
}
type LinkedList struct {
head *Node
tail *Node
}
func (list *LinkedList) insertAtBeginning(data int) {
newNode := &Node{
data: data,
previous: nil,
next: nil,
}
if list.head == nil {
list.head = newNode
list.tail = newNode
return
}
newNode.next = list.head
list.head.previous = newNode
list.head = newNode
}
func (list *LinkedList) insertAtEnd(data int) {
newNode := &Node{
data: data,
previous: nil,
next: nil,
}
if list.tail == nil {
list.head = newNode
list.tail = newNode
return
}
newNode.previous = list.tail
list.tail.next = newNode
list.tail = newNode
}
func (list *LinkedList) delete(data int) bool {
currentNode := list.head
for currentNode != nil {
if currentNode.data == data {
if currentNode == list.head {
list.head = currentNode.next
list.head.previous = nil
} else if currentNode == list.tail {
list.tail = currentNode.previous
list.tail.next = nil
} else {
currentNode.previous.next = currentNode.next
currentNode.next.previous = currentNode.previous
}
return true
}
currentNode = currentNode.next
}
return false
}
func (list *LinkedList) display() {
currentNode := list.head
for currentNode != nil {
fmt.Printf("%d ", currentNode.data)
currentNode = currentNode.next
}
fmt.Println()
}
func main() {
list := LinkedList{}
list.insertAtEnd(1)
list.insertAtEnd(2)
list.insertAtEnd(3)
list.insertAtBeginning(4)
list.display()
list.delete(3)
list.display()
}Dans le code ci-dessus, nous définissons d'abord une structure Node, qui contient les informations requises pour chaque nœud de la liste chaînée Trois données : données, précédent et suivant. Parmi eux, data stocke la valeur du nœud, previous stocke l'adresse du nœud précédent et next stocke l'adresse du nœud suivant . Node 结构体，该结构体包含链表中的每个节点所需的三个数据：data、previous 和 next。其中，data 存储节点的值，previous 存储上一个节点的地址，next 存储下一个节点的地址。
然后，我们定义了一个 LinkedList 结构体来表示整个链表。该结构体包含链表的头指针 head 和尾指针 tail。
下面是实现双向链表所需的几个方法：
// 在链表头部插入一个元素
func (list *LinkedList) insertAtBeginning(data int) {
newNode := &Node{
data: data,
previous: nil,
next: nil,
}
if list.head == nil {
list.head = newNode
list.tail = newNode
return
}
newNode.next = list.head
list.head.previous = newNode
list.head = newNode
}
// 在链表尾部插入一个元素
func (list *LinkedList) insertAtEnd(data int) {
newNode := &Node{
data: data,
previous: nil,
next: nil,
}
if list.tail == nil {
list.head = newNode
list.tail = newNode
return
}
newNode.previous = list.tail
list.tail.next = newNode
list.tail = newNode
}
// 删除链表中指定的元素
func (list *LinkedList) delete(data int) bool {
currentNode := list.head
for currentNode != nil {
if currentNode.data == data {
if currentNode == list.head {
list.head = currentNode.next
list.head.previous = nil
} else if currentNode == list.tail {
list.tail = currentNode.previous
list.tail.next = nil
} else {
currentNode.previous.next = currentNode.next
currentNode.next.previous = currentNode.previous
}
return true
}
currentNode = currentNode.next
}
return false
}
// 打印链表的所有元素
func (list *LinkedList) display() {
currentNode := list.head
for currentNode != nil {
fmt.Printf("%d ", currentNode.data)
currentNode = currentNode.next
}
fmt.Println()
}在定义了这几个方法后，我们可以在 main 函数中实例化一个链表对象并进行操作：
func main() {
list := LinkedList{}
list.insertAtEnd(1)
list.insertAtEnd(2)
list.insertAtEnd(3)
list.insertAtBeginning(4)
list.display()
list.delete(3)
list.display()
}在上面的代码中，我们首先实例化了一个 LinkedList 对象 list，然后我们按顺序插入了四个元素：1、2、3 和 4。我们在第一次调用 display 方法时，将输出链表的内容：
4 1 2 3
接着，我们删除了元素 3，并再次调用 display
LinkedList pour représenter l'intégralité de la liste chaînée. Cette structure contient le pointeur de tête head et le pointeur de queue tail de la liste chaînée. Voici plusieurs méthodes nécessaires pour implémenter une liste doublement chaînée : 🎜4 1 2
main et effectuer des opérations : 🎜rrreee 🎜Dans le au-dessus du code, nous instancions d'abord un objet LinkedList list, puis nous insérons quatre éléments dans l'ordre : 1, 2, 3 et 4. Lorsque nous appellerons la méthode display pour la première fois, nous afficherons le contenu de la liste chaînée : 🎜rrreee🎜Ensuite, nous supprimons l'élément 3 et appelons à nouveau la méthode display pour afficher le contenu de la liste chaînée Dernier contenu : 🎜rrreee🎜Cette simple implémentation Golang d'une liste doublement chaînée montre comment utiliser des pointeurs pour créer et modifier des listes chaînées, et comment implémenter des opérations telles que l'insertion, la suppression et l'interrogation de listes chaînées . Si vous devez utiliser des listes doublement liées pour créer des structures de données efficaces, veuillez vous référer au code ci-dessus pour savoir comment implémenter des listes doublement liées dans Golang. 🎜Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
