How to implement linked list in go

A linked list is a common data structure that consists of a series of nodes, each node containing data and a pointer to the next node. Linked lists can be used to store and operate large amounts of data, and they have efficient performance for inserting and deleting elements. In Go language, we can use pointers and structures to implement linked lists.

First, we need to define a node structure, which contains data and a pointer to the next node. In Go language, you can use structures to define nodes.

type Node struct {
data int
next *Node
}

Next, we can define a linked list structure, which contains a pointer to the head node of the linked list.

type LinkedList struct {
head *Node
}

In the linked list structure, we can define some methods to operate the linked list. First, we need to implement a method to insert a node at the end of the linked list.

func (list *LinkedList) Insert(data int) {
newNode := &Node{data: data, next: nil}
if list.head == nil {
list.head = newNode
} else {
current := list.head
for current.next != nil {
current = current.next
}
current.next = newNode
}
}

In this method, we first create a new node and assign data to it. Then, we check if the linked list is empty, and if so, set the new node as the head node of the linked list. Otherwise, we traverse the linked list until we find the last node, and then insert the new node after the last node.

Next, we can implement a method to delete a node in the linked list.

func (list *LinkedList) Delete(data int) {
if list.head == nil {
return
}
if list.head.data == data {
list.head = list.head.next
return
}
current := list.head
for current.next != nil {
if current.next.data == data {
current.next = current.next.next
return
}
current = current.next
}
}

In this method, we first check whether the linked list is empty, and if it is empty, return directly. We then check if the head node of the linked list contains the data to be deleted, and if so, set the node next to the head node as the new head node. Otherwise, we traverse the linked list until we find the node containing the data to be deleted, and then set the next node of that node to the next node of the current node.

Finally, we can implement a method to print all nodes in the linked list.

func (list *LinkedList) Print() {
current := list.head
for current != nil {
fmt.Println(current.data)
current = current.next
}
}

In this method, we traverse the linked list starting from the head node of the linked list, print the data of each node, and point the current node to the next node.

Using the above method, we can create a linked list and insert, delete and print nodes in it.

func main() {
list := LinkedList{}
list.Insert(1)
list.Insert(2)
list.Insert(3)
list.Print() // 输出：1 2 3
list.Delete(2)
list.Print() // 输出：1 3
}

Through the above code, we can see that the creation, insertion, deletion and printing operations of the linked list can be easily implemented. This is the basic method of implementing linked lists in Go language.

The above is the detailed content of How to implement linked list in go. For more information, please follow other related articles on the PHP Chinese website!