单向链表是由一系列节点组成的数据结构，其中每个节点都包含一个值和一个指向序列中下一个节点的引用。在单向链表中，每个节点只有对下一个节点的引用，没有对前一个节点的引用。在未排序的链表中，节点的顺序无关紧要，可以在列表中的任何位置插入或删除它们。
要访问链表中的特定节点，我们从头节点(链表中的第一个节点)开始，然后按照链接操作，直到到达所需的节点。如果某个节点对其下一个节点的引用为null，则将其视为链表中的最后一个节点。
单向无序链表是一种有用的数据结构，用于实现许多算法，例如搜索、排序和图遍历算法。但是，它们在按索引访问元素方面不如数组或其他数据结构高效，因为我们必须从头开始遍历链表才能找到特定元素。

示例代码：

package main

import (
    "fmt"
)

type Node struct {
    data int
    next *Node
}

type List struct {
    head *Node
}

func (l *List) add(value int) {
    newNode := &Node{data: value}

    if l.head == nil {
        l.head = newNode
        return
    }

    curr := l.head
    for curr.next != nil {
        curr = curr.next
    }

    curr.next = newNode
}

func (l *List) remove(value int) {
    if l.head == nil {
        return
    }

    if l.head.data == value {
        l.head = l.head.next
        return
    }

    curr := l.head
    for curr.next != nil && curr.next.data != value {
        curr = curr.next
    }

    if curr.next != nil {
        curr.next = curr.next.next
    }
}

func main() {
    list := &List{}
    list.add(1)
    list.add(2)
    list.add(3)
    list.add(4)

    fmt.Println("Initial List: ")
    printList(list)

    list.remove(2)
    fmt.Println("List after removing 2: ")
    printList(list)

    list.remove(4)
    fmt.Println("List after removing 4: ")
    printList(list)
}

func printList(l *List) {
    curr := l.head
    for curr != nil {
        fmt.Printf("%d ", curr.data)
        curr = curr.next
    }
    fmt.Println()
}
首先，我们定义了两个结构：Node和List。Node结构表示链表中的单个节点，其中包含数据和指向下一个节点的指针。List结构包含指向头节点的指针。
接下来，我们定义add函数，该函数接受一个值并将其添加到列表末尾。如果列表为空，则新节点将成为头节点。否则，我们遍历列表以查找最后一个节点，然后将新节点追加到该节点。
然后，我们定义remove函数，该函数接受一个值并从列表中删除它的第一个出现。如果列表为空，或者未找到值，则该函数不执行任何操作。如果在头节点上找到该值，我们只需更新头指针。否则，我们遍历列表以查找要删除的节点之前的节点，然后更新其下一个指针以跳过要删除的节点。
最后，在main函数中，我们创建一个新列表并向其添加一些节点。然后，我们打印初始列表，删除几个节点，然后再次打印列表以查看更改。