golang implements doubly linked list-Golang-php.cn

golang implements doubly linked list

王林

Release： 2023-05-10 22:37:37

Original

564 people have browsed it

Doubly linked list (Doubly linked list) is a commonly used data structure, which allows us to perform insertion, deletion or query operations at any position in the linked list within O(1) time complexity.

Implementing a doubly linked list in Golang requires the use of pointers, because all types in Golang are value types and the original data cannot be modified directly. Through pointers, we can easily modify and transfer values, thereby realizing the operation of doubly linked lists.

The following is a simple Golang implementation of a doubly linked list:

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()
}

Copy after login

In the above code, we first define a Node structure, which contains a linked list Three pieces of data are required for each node in: data, previous, and next. Among them, data stores the value of the node, previous stores the address of the previous node, and next stores the address of the next node.

Then, we define a LinkedList structure to represent the entire linked list. This structure contains the head pointer head and the tail pointer tail of the linked list.

The following are several methods required to implement a doubly linked list:

// 在链表头部插入一个元素
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()
}

Copy after login

After defining these methods, we can instantiate a linked list in the main function Object and perform operations:

func main() {
    list := LinkedList{}

    list.insertAtEnd(1)
    list.insertAtEnd(2)
    list.insertAtEnd(3)
    list.insertAtBeginning(4)

    list.display()

    list.delete(3)

    list.display()
}

Copy after login

In the above code, we first instantiate a LinkedList object list, and then we insert four elements in order: 1, 2, 3 and 4. When we call the display method for the first time, we will output the contents of the linked list:

4 1 2 3

Copy after login

Then, we delete element 3 and call the display method again to output The latest content of linked lists:

4 1 2

Copy after login

This simple Golang implementation of a doubly linked list demonstrates how to use pointers to create and modify linked lists, and how to implement operations such as insertion, deletion and query of linked lists. If you need to use doubly linked lists to create efficient data structures, please refer to the above code to learn how to implement doubly linked lists in Golang.

The above is the detailed content of golang implements doubly linked list. For more information, please follow other related articles on the PHP Chinese website!