Pelaksanaan Senarai Berpaut Tunggal dalam Go

Hai DEV.kepada komuniti!

Ini adalah sebahagian daripada siri struktur data dan algoritma saya. Dalam artikel ini, kami akan melaksanakan senarai pautan tunggal kemudian dalam artikel seterusnya daripada siri ini saya akan melaksanakan senarai terpaut lain juga menggunakan Go.

Untuk melaksanakan senarai pautan tunggal kita perlu struktur, nod dan senarai pautan tunggal itu sendiri. Tetapi sebelum mula membuat kod di sini ialah cara saya ingin mengatur kod saya:

project
├── singly_linked_list
│   ├── node.go
│   └── list.go
└── main.go

Nod

Nod hanya menyimpan data dan penunjuk ke nod seterusnya dalam bentuk yang paling mudah. Oleh itu, inilah struct yang akan kita gunakan sebagai nod (dalam fail node.go):

type SinglyNode struct {
    data interface{}
    next *SinglyNode
}

Kami menggunakan antara muka{} sebagai jenis data untuk data dalam struct supaya kami boleh menyimpan sebarang data yang kami mahukan di dalam nod.

Kemudian kita harus menentukan beberapa kaedah untuk menggunakan struct nod yang baru kita buat.

func NewSinglyNode(data interface{}) *SinglyNode {
    return &SinglyNode{data: data}
}

Jika anda biasa dengan bahasa berorientasikan objek, anda berkemungkinan besar sudah biasa dengan apa itu pembina. Memandangkan Go bukan bahasa berorientasikan objek, tiada kelas tetapi mengikut beberapa konvensyen di seluruh dunia Go, kami biasanya mencipta fungsi yang diawali dengan perkataan Baharu. Tetapi perlu diingat bahawa dalam bahasa OOP baharu ialah kata kunci khas yang bermaksud mencipta objek. Di sini Baharu hanyalah awalan nama dan tidak lebih.

Fungsi NewSinglyNode hanya menerima satu hujah yang dipanggil data dengan jenis antara muka{} dan mengembalikan penunjuk SinglyNode.

Seterusnya, kami mentakrifkan beberapa getter dan setter untuk nod:

func (n *SinglyNode) SetData(data interface{}) {
    n.data = data
}

func (n *SinglyNode) SetNext(next *SinglyNode) {
    n.next = next
}

func (n *SinglyNode) GetData() interface{} {
    return n.data
}

func (n *SinglyNode) GetNext() (*SinglyNode, error) {
    if n.next == nil {
        return nil, errors.New("no next node")
    }
    return n.next, nil
}

SetData, Setnext dan GetData cukup jelas. GetNext mengembalikan dua nilai, penunjuk ke SinglyNode seterusnya dan ralat jika tiada nod seterusnya.

Berikut ialah fungsi tambahan yang selalu saya suka tambah supaya saya sentiasa tahu bagaimana perwakilan rentetan struct saya:

func (n *SinglyNode) ToString() string {
    return n.data.(string)
}

Senaraikan

Sekarang kita selesai dengan nod kita, kita harus melaksanakan senarai itu sendiri. Senarai pautan tunggal memegang nod pertama sebagai kepala dan untuk pilihan saya sendiri, dua lagi data yang dipanggil terakhir memegang nod terakhir dan sifat negara yang memegang kiraan nod yang ditambahkan pada senarai.

Jadi, berikut ialah baris pertama fail list.go:

type SinglyLinkedList struct {
    head  *SinglyNode
    last  *SinglyNode
    count int
}

Dan jelas sekali, fungsi seperti pembina untuk mencipta SinglyLinkedList dengan mudah:

func NewSinglyLinkedList() *SinglyLinkedList {
    return &SinglyLinkedList{}
}

Fungsi paling penting dalam senarai terpaut ialah fungsi yang menambah nod. Berikut ialah pelaksanaan saya bagi fungsi sedemikian:

func (l *SinglyLinkedList) AttachNode(node *SinglyNode) {
    if l.head == nil {
        l.head = node
    } else {
        l.last.SetNext(node)
    }
    l.last = node
    l.count++
}

Fungsi melakukan seperti di bawah:

• Semak sama ada kepala senarai terpaut kosong, jika demikian tetapkan nod yang diterima sebagai ketua senarai.
• Jika kepala tidak kosong, ia menetapkan nod yang diterima sebagai sifat seterusnya bagi nod terakhir.
• Tidak kira apa yang berlaku sebelum ini, nod semasa hendaklah menjadi nod terakhir supaya apabila nod ditambahkan seterusnya, ia boleh ditetapkan sebagai nod seterusnya untuk nod terakhir dalam senarai kami.
• Tingkatkan kiraan sebanyak satu.

Berikut ialah fungsi yang menerima data dan mencipta nod dan menghantarnya ke fungsi AttachNode:

func (l *SinglyLinkedList) Add(data interface{}) {
    l.AttachNode(NewSinglyNode(data))
}

Walaupun fungsi ini mungkin kelihatan berlebihan, ia akan memudahkan penambahan nod pada senarai tanpa membuat satu secara manual setiap kali.

Fungsi untuk mendapatkan harta kiraan juga:

func (l *SinglyLinkedList) Count() int {
    return l.count
}

Fungsi terakhir yang diperlukan ialah fungsi yang sepatutnya mengembalikan nod seterusnya dalam senarai terpaut:

func (l *SinglyLinkedList) GetNext() (*SinglyNode, error) {
    if l.head == nil {
        return nil, errors.New("list is empty")
    }
    return l.head, nil
}

Saya lebih suka menamakan fungsi ini sama seperti fungsi GetNext yang ditakrifkan untuk nod. Ini dilakukan supaya lebih konsisten. Apabila mula-mula mengakses senarai terpaut jenisnya ialah senarai terpaut jadi tiada akses kepada fungsi yang ditentukan untuk nod. Menentukan fungsi dengan nama yang sama akan membolehkan anda menggunakan GetNext seberapa banyak yang anda mahu melintasi senarai anda.

Satu fungsi tambahan yang selalu saya cenderung tambah ialah fungsi untuk mendapatkan semula nod mengikut indeks:

func (l *SinglyLinkedList) GetByIndex(index int) (*SinglyNode, error) {
    if l.head == nil {
        return nil, errors.New("list is empty")
    }
    if index+1 > l.count {
        return nil, errors.New("index out of range")
    }
    node, _ := l.GetNext()
    for i := 0; i < index; i++ {
        node, _ = node.GetNext()
    }
    return node, nil
}

Fungsi ini melakukan seperti di bawah:

• Periksa sama ada kepala kosong untuk mengembalikan ralat
• Semak sama ada indeks 1 lebih besar daripada kiraan senarai untuk mengembalikan ralat. Kami menyemak indeks 1 dan bukan untuk indeks kerana kami menganggap indeks bermula dari 0 sama seperti tatasusunan.
• Tetapkan l.GetNext() kepada pembolehubah bernama nod (abaikan ralat dengan _) kemudian gelung untuk satu kurang daripada indeks yang disediakan kerana kita sudah mempunyai yang pertama disimpan dalam pembolehubah nod, menetapkan nod seterusnya semasa nod sebagai nod sekali lagi.
• Kembalikan nod yang dilalui tanpa ralat.

Menguji

Sekarang kami mempunyai senarai terpaut dan definisi nod, kami boleh mengujinya dalam fail main.go kami seperti di bawah:

func main() {
    list := singly_linked_list.NewSinglyLinkedList()

    list.Add("One")
    list.Add("Two")
    list.Add("Three")

    firstNode, err := list.GetNext()
    if err != nil {
        panic(err)
    }

    secondNode, err := firstNode.GetNext()
    if err != nil {
        panic(err)
    }

    thirdNode, err := secondNode.GetNext()
    if err != nil {
        panic(err)
    }

    println(firstNode.ToString())  // One
    println(secondNode.ToString()) // Two
    println(thirdNode.ToString())  // Three
}

Atau menggunakan fungsi GetByIndex:

func main() {
    list := singly_linked_list.NewSinglyLinkedList()

    list.Add("One")
    list.Add("Two")
    list.Add("Three")

    node, err := list.GetByIndex(2)
    if err != nil {
        panic(err)
    }

    fmt.Println(node.ToString()) // Three
}

BTW! Lihat E-buku Node.js Essentials percuma saya di sini:

NodeJS Essentials | E-Book Percuma

Adnan Babakan (dia) ・ Sep 11 '20

#nod #javascript #buku

Sila hubungi saya jika anda mempunyai sebarang soalan atau cadangan.

Atas ialah kandungan terperinci Pelaksanaan Senarai Berpaut Tunggal dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!