Bagaimana untuk melaksanakan senarai terpaut dalam golang

Senarai terpaut ialah struktur data biasa yang terdiri daripada satu siri nod, setiap nod mengandungi data dan penuding ke nod seterusnya. Dalam artikel ini, kami akan menggunakan bahasa Go untuk melaksanakan senarai terpaut mudah.

1. Tentukan jenis nod

Pertama, kita perlu menentukan jenis nod. Nod harus mengandungi elemen data dan penunjuk ke nod seterusnya. Kodnya adalah seperti berikut:

type Node struct {
    Data interface{} //节点存储的数据
    Next *Node       //指向下一个节点的指针
}

Kami menggunakan antara muka{} untuk menyimpan data nod, yang membenarkan senarai terpaut menyimpan sebarang jenis data.

2. Tentukan jenis senarai terpaut

Seterusnya, kita perlu menentukan jenis senarai terpaut. Ia harus mengandungi penunjuk ke nod pertama. Pada masa yang sama, kami juga menambah dua kaedah: AddNode dan Traverse.

type LinkedList struct {
    Head *Node //指向第一个节点的指针
}

//添加一个节点
func (l *LinkedList) AddNode(data interface{}) {
    newNode := &Node{Data: data}

    if l.Head == nil {
        l.Head = newNode
    } else {
        current := l.Head
        for current.Next != nil {
            current = current.Next
        }
        current.Next = newNode
    }
}

//遍历链表并执行函数
func (l *LinkedList) Traverse(fn func(interface{})) {
    current := l.Head
    for current != nil {
        fn(current.Data)
        current = current.Next
    }
}

Kaedah AddNode menambah nod pada penghujung senarai terpaut. Jika senarai terpaut kosong, nod yang ditambah menjadi nod pertama. Jika tidak, kami merentasi senarai terpaut, cari nod terakhir dan tambah nod baharu sebagai nod seterusnya.

Kaedah Traverse menggunakan fungsi panggil balik untuk mengendalikan setiap nod dalam senarai terpaut. Ia berulang melalui setiap nod dalam senarai terpaut dan kemudian melaksanakan fungsi yang diluluskan pada setiap nod. Kita boleh menggunakan kaedah ini untuk lelaran melalui senarai terpaut dan mencetak setiap nod:

func main() {
    list := LinkedList{}
    list.AddNode("A")
    list.AddNode("B")
    list.AddNode("C")

    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })
}

Kod di atas akan mencetak:

A
B
C

3. Padam Nod

Sekarang, mari Tambah kaedah untuk memadamkan nod daripada senarai terpaut.

//删除链表中的节点
func (l *LinkedList) RemoveNode(target interface{}) {
    if l.Head == nil {
        return
    }

    if l.Head.Data == target {
        l.Head = l.Head.Next
        return
    }

    current := l.Head
    for current.Next != nil {
        if current.Next.Data == target {
            current.Next = current.Next.Next
            return
        }
        current = current.Next
    }
}

Kaedah RemoveNode mengambil parameter yang mengenal pasti nod untuk dipadamkan dan merentasi senarai terpaut untuk mencari nod. Jika nod ditemui, tukar penuding seterusnya nod semasa untuk mengeluarkannya daripada senarai terpaut. Jika senarai terpaut kosong atau nod tidak ditemui, tiada tindakan dilakukan.

Kod penuh:

package main

import "fmt"

type Node struct {
    Data interface{} //节点存储的数据
    Next *Node       //指向下一个节点的指针
}

type LinkedList struct {
    Head *Node //指向第一个节点的指针
}

//添加一个节点
func (l *LinkedList) AddNode(data interface{}) {
    newNode := &Node{Data: data}

    if l.Head == nil {
        l.Head = newNode
    } else {
        current := l.Head
        for current.Next != nil {
            current = current.Next
        }
        current.Next = newNode
    }
}

//遍历链表并执行函数
func (l *LinkedList) Traverse(fn func(interface{})) {
    current := l.Head
    for current != nil {
        fn(current.Data)
        current = current.Next
    }
}

//删除链表中的节点
func (l *LinkedList) RemoveNode(target interface{}) {
    if l.Head == nil {
        return
    }

    if l.Head.Data == target {
        l.Head = l.Head.Next
        return
    }

    current := l.Head
    for current.Next != nil {
        if current.Next.Data == target {
            current.Next = current.Next.Next
            return
        }
        current = current.Next
    }
}

func main() {
    list := LinkedList{}
    list.AddNode("A")
    list.AddNode("B")
    list.AddNode("C")

    //遍历链表
    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })

    //删除节点并再次遍历链表
    list.RemoveNode("B")
    list.Traverse(func(data interface{}) {
        fmt.Println(data)
    })
}

Kod di atas akan dicetak:

A
B
C
A
C

4. Ringkasan

Dalam artikel ini, kami menggunakan Go The bahasa melaksanakan senarai terpaut mudah. Senarai terpaut ialah struktur data penting yang digunakan secara meluas dalam banyak senario pembangunan algoritma dan perisian. Apabila menulis kod sebenar, pertimbangkan untuk menambah fungsi tambahan dan menilai prestasi.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan senarai terpaut dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!