golang melintasi untuk memadam elemen

Dalam bahasa Go, melintasi dan memadam elemen adalah keperluan yang agak biasa. Walau bagaimanapun, disebabkan ciri khas bahasa Go, beberapa butiran perlu diberi perhatian. Artikel ini akan memperkenalkan perkara yang anda perlu beri perhatian semasa melintasi dan memadam elemen dalam bahasa Go dan cara melaksanakannya dengan betul.

Struktur data hirisan dan peta bahasa Go sangat mudah digunakan. Potongan boleh berkembang secara automatik, dan peta boleh mengakses nilai yang sepadan dengan cepat berdasarkan nilai utama. Ciri-ciri ini menjadikan bahasa Go sangat sesuai untuk memproses sejumlah besar data. Walau bagaimanapun, apabila melintasi kepingan dan peta dan memadamkan elemen, anda perlu memberi perhatian kepada isu berikut.

1. Lintas hirisan untuk memadam elemen

Apabila memadamkan elemen dalam hirisan, anda perlu memberi perhatian kepada perkara berikut:

1) Lakukan tidak mengubah suai hirisan semasa traversal

Memadamkan hirisan secara langsung semasa traversal akan menyebabkan kegagalan indeks, mengakibatkan pemadaman tidak sengaja atau terlepas. Contohnya:

func main() {
    nums := []int{1, 2, 3, 4, 5}
    for i, n := range nums {
        if n == 3 {
            nums = append(nums[:i], nums[i+1:]...)
        }
    }
    fmt.Println(nums) // 1 2 4 5
}

Kod di atas akan memadamkan elemen 3 apabila ia dilalui. Walau bagaimanapun, memandangkan panjang dan indeks hirisan telah diubah suai semasa memadamkan elemen, indeks elemen berikutnya berubah Sebenarnya, hanya elemen 3 selepas 4 dipadamkan, dan 3 itu sendiri tidak dipadamkan .

Untuk mengelakkan situasi ini, anda boleh menggunakan kepingan lain untuk merekodkan subskrip elemen yang akan dipadamkan, dan kemudian melakukan operasi pemadaman selepas melintasi. Contohnya:

func main() {
    nums := []int{1, 2, 3, 4, 5}
    delIdx := []int{}
    for i, n := range nums {
        if n == 3 {
            delIdx = append(delIdx, i)
        }
    }
    for i, idx := range delIdx {
        nums = append(nums[:idx-i], nums[idx-i+1:]...)
    }
    fmt.Println(nums) // 1 2 4 5
}

Dalam kod di atas, hirisan kosongdelIdx mula-mula ditakrifkan untuk merekodkan subskrip elemen yang akan dipadamkan. Apabila merentasi nums, jika elemen yang akan dipadamkan ditemui, subskrip elemen itu ditambahkan pada delIdx. Selepas perjalanan selesai, padamkan nums.

2) Gunakan "tiga penunjuk" untuk melaksanakan pemadaman

Cara lain untuk memadamkan elemen semasa melintasi kepingan ialah menggunakan kaedah "tiga penunjuk". Iaitu, gunakan penunjuk i untuk melintasi kepingan, penunjuk j untuk merekodkan bilangan elemen yang akan dipadamkan dan penunjuk k untuk merekodkan elemen biasa. Pelaksanaan khusus adalah seperti berikut:

func main() {
    nums := []int{1, 2, 3, 4, 5}
    j := 0
    for i := range nums {
        if nums[i] != 3 {
            nums[j] = nums[i]
            j++
        }
    }
    nums = nums[:j]
    fmt.Println(nums) // 1 2 4 5
}

Dalam kod di atas, tentukan penunjuk j dahulu untuk mewakili bilangan elemen yang akan dipadamkan. Kemudian gunakan penuding i untuk melintasi hirisan Jika elemen semasa tidak perlu dipadamkan, alihkannya ke lokasi penuding k, dan kemudian tambah 1 pada k, menunjukkan bahawa bilangan biasa bagi. elemen telah meningkat sebanyak 1. Jika elemen semasa perlu dipadamkan, langkau sahaja. Pada penghujung traversal, gunakan nums[:j] untuk mengalih keluar elemen berlebihan.

2. Lintas peta untuk memadamkan elemen

Dalam peta bahasa Go, operasi pemadaman elemen adalah sangat mudah. Hanya gunakan fungsi delete. Contohnya:

func main() {
    m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}
    for k, v := range m {
        if v == 3 {
            delete(m, k)
        }
    }
    fmt.Println(m) // map[a:1 b:2 d:4]
}

memadamkan elemen semasa melintasi peta dan tidak akan berlaku kegagalan indeks. Kerana peta tidak teratur, kedudukan setiap elemen tidak penting. Oleh itu, hanya gunakan fungsi delete secara terus semasa traversal.

Perlu diambil perhatian bahawa panjang peta tidak boleh diubah suai semasa melintasi peta. Contohnya, kod berikut akan menyebabkan panik:

func main() {
    m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}
    for k := range m {
        if k == "c" {
            m["e"] = 5
        }
        fmt.Println(m[k])
    }
}

Apabila melintasi elemen dengan kekunci c, kod itu menambah pasangan nilai kunci baharu "e":5 pada peta. Kerana panjang peta berubah, ia akan menyebabkan panik masa jalan.

Ringkasnya, perkara yang anda perlu beri perhatian semasa melintasi dan memadam elemen dalam bahasa Go ialah:

1) Apabila melintasi kepingan untuk memadam elemen, jangan padamkan hirisan secara langsung . Anda harus menggunakan kepingan lain untuk merekodkan subskrip elemen yang akan dipadamkan, dan kemudian melakukan operasi pemadaman selepas melintasi atau menggunakan "tiga penunjuk" untuk melaksanakan pemadaman.

2) Apabila melintasi peta untuk memadamkan elemen, anda boleh menggunakan fungsi delete terus tanpa kegagalan indeks. Tetapi panjang peta tidak boleh diubah suai semasa merentasi.

Selepas menguasai kemahiran di atas, kami boleh melaksanakan operasi melintasi dan memadam elemen dalam bahasa Go dengan betul.

Atas ialah kandungan terperinci golang melintasi untuk memadam elemen. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!