Golang implements singly linked list

Singly linked list is a data structure that consists of a series of nodes, each node contains a data and a pointer to the next node. The pointer of the last node of a singly linked list is null, indicating the end of the linked list.

In Golang, we can use a structure to define each node and use a pointer to indicate the location of the next node. The following is a simple singly linked list implementation:

package main

import "fmt"

type Node struct {
    data int
    next *Node
}

type List struct {
    head *Node
}

func (l *List) Insert(val int) {
    newNode := &Node{data: val}

    if l.head == nil {
        l.head = newNode
    } else {
        last := l.Last()
        last.next = newNode
    }
}

func (l *List) Last() *Node {
    node := l.head

    for node.next != nil {
        node = node.next
    }

    return node
}

func (l *List) Traverse() {
    node := l.head

    for node != nil {
        fmt.Printf("%d ", node.data)
        node = node.next
    }

    fmt.Printf("
")
}

func main() {
    l := List{}

    for i := 0; i < 10; i++ {
        l.Insert(i)
    }

    l.Traverse()
}

In this implementation, we define the Node structure, which contains a data and a next pointer pointing to the next node. The List structure represents the entire linked list and contains a head pointer pointing to the first node.

The Insert method is used to insert a value into the linked list. If the linked list is empty, set the new node as head directly; otherwise, find the last node and point its next pointer to the new node.

Last method returns the last node of the linked list. Starting from head, traverse the entire linked list until the last node is found.

The Traverse method is used to traverse the entire linked list and output all elements in the linked list.

In the main function, we create a List instance, insert values ​​into it, and traverse the entire linked list to output the results.

The above implementation is just a simple example and can be extended and modified according to your own needs. It is worth noting that in actual development, when writing linked lists, we need to pay attention to issues such as memory leaks and pointer null value judgment to ensure the robustness and efficiency of the code.

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