Mereka bentuk dan melaksanakan struktur data senarai terpaut di Golang

Reka bentuk dan pelaksanaan struktur data senarai terpaut di Golang

Pengenalan:
Senarai terpaut ialah struktur data biasa yang digunakan untuk menyimpan satu siri nod. Setiap nod mengandungi data dan penunjuk ke nod seterusnya. Di Golang, kita boleh melaksanakan senarai terpaut dengan menggunakan struktur dan penunjuk.

1. Definisi reka bentuk dan struktur senarai terpaut
   Di Golang, kita boleh menggunakan struktur dan penunjuk untuk mentakrifkan nod senarai terpaut dan struktur senarai terpaut itu sendiri. Struktur nod mengandungi medan data dan penunjuk ke nod seterusnya.

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

type LinkedList struct {
    head *Node // 链表头节点的指针
}

2. Inisialisasi senarai terpaut
   Apabila membuat senarai terpaut, kita perlu memulakan senarai terpaut kosong. Apabila memulakan senarai terpaut, penunjuk nod kepala senarai terpaut kosong.

func NewLinkedList() *LinkedList {
    return &LinkedList{}
}

3. Sisipan ke dalam senarai terpaut
   Sisipan ke dalam senarai terpaut menambahkan nod pada penghujung senarai terpaut. Pertama, kita perlu mencipta nod baharu dan memberikan data kepadanya. Kemudian, kami mencari nod terakhir senarai terpaut dan halakan penuding next ke nod baharu. next指针指向新节点。

func (list *LinkedList) Insert(data interface{}) {
    newNode := &Node{data: data} // 创建新节点
    if list.head == nil {        // 链表为空
        list.head = newNode     // 直接将新节点设为头节点
    } else {
        current := list.head
        for current.next != nil {
            current = current.next // 找到链表的最后一个节点
        }
        current.next = newNode // 将新节点链接到最后一个节点的next指针
    }
}

4. 链表的删除
   链表的删除操作将找到并删除链表中特定节点。首先，我们需要找到要删除的节点的前一个节点，并将其next指针设置为被删除节点的next

func (list *LinkedList) Delete(data interface{}) {
    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
    }
}

Salin selepas log masuk
Pemadaman senarai terpaut
Operasi pemadaman senarai terpaut akan mencari dan memadamkan nod tertentu dalam senarai terpaut. Mula-mula, kita perlu mencari nod sebelumnya bagi nod yang hendak dipadamkan dan menetapkan penuding nextnya kepada penuding next nod yang dipadamkan.
5. 
   

   func (list *LinkedList) Traverse() {
       if list.head == nil {
           return // 链表为空
       }
       current := list.head
       for current != nil {
           fmt.Println(current.data)
           current = current.next
       }
   }

   Salin selepas log masuk
Perjalanan senarai terpaut
Operasi lintasan senarai terpaut akan mencetak semua nod dalam senarai terpaut.

func main() {
    list := NewLinkedList() // 创建一个新链表
    list.Insert(1)          // 插入节点1
    list.Insert(2)          // 插入节点2
    list.Insert(3)          // 插入节点3

    list.Traverse() // 遍历链表，输出: 1 2 3

    list.Delete(2)  // 删除节点2
    list.Traverse() // 遍历链表，输出: 1 3
}

Salin selepas log masuk

Contoh penggunaan senarai terpaut


rrreee🎜Kesimpulan: 🎜Di Golang, dengan menggunakan struktur dan penunjuk, kami boleh melaksanakan struktur data senarai terpaut dengan mudah. Operasi sisipan, pemadaman dan lintasan senarai terpaut juga sangat mudah dan jelas, dan boleh digunakan dengan mudah untuk masalah praktikal. 🎜

Atas ialah kandungan terperinci Mereka bentuk dan melaksanakan struktur data senarai terpaut di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!