Cari persimpangan dua senarai yang disusun di Kotlin dan padamkan elemen senarai yang berkaitan

Artikel ini akan meneroka secara mendalam bagaimana untuk melaksanakan operasi persimpangan senarai yang dipautkan di Kotlin, dan memberikan contoh dan penjelasan kod terperinci.

Pertama, mari kita semak Ringkasan Artikel: Artikel ini memperincikan bagaimana untuk melaksanakan fungsi di Kotlin yang mengira persimpangan dua senarai gelung dua arah yang disusun dan menghilangkan unsur -unsur persimpangan ini dari senarai asal. Fungsi ini menggunakan komparator yang diberikan untuk menyusun senarai yang dipautkan, dan menggunakan semula nod salah satu senarai yang dipautkan untuk membina senarai persimpangan baru, mengelakkan unsur-unsur pendua, dan akhirnya mengembalikan senarai yang tidak disusun tanpa gelung, sentinel yang disusun.

Penerangan Masalah

Memandangkan dua senarai gelung dua arah List1 dan List2, kedua -duanya disusun mengikut urutan menaik mengikut CMMP Comparator. Matlamatnya adalah untuk mencari persimpangan kedua -dua senarai yang dipautkan ini dan membuat senarai yang dipautkan baru yang mengandungi unsur -unsur yang wujud dalam List1 dan List2. Di samping itu, unsur -unsur persimpangan ini perlu dikeluarkan dari senarai yang dipautkan asal List1 dan List2. Senarai yang dipautkan baru mestilah bidirectional, bukan kitaran, dan tidak mengandungi nod sentinel, sambil mengekalkan perintah menaik dan tidak boleh mengandungi unsur-unsur pendua.

Takrif nod nod adalah seperti berikut:

 Node Kelas <e> {
    var Sebelumnya: Node <e>? = null
    var Seterusnya: Node <e>? = null
    Nilai var: e? = null
}</e></e></e>

Penyelesaian

Kod Kotlin berikut melaksanakan fungsi persimpangan, yang digunakan untuk mengira persimpangan dua senarai yang disusun dan memadam elemen dalam senarai yang dipautkan asal:

 Fun <e> persimpangan (List1: Node <e>, List2: Node <e>, CMP: Comparator <e>): Node <e>? {
    Senarai VAR: Node <e>? = null // nod ekor senarai baru yang dipautkan var temp = list1 // penunjuk senarai baru yang dipautkan var temp2 = list2 // penunjuk senarai baru yang dipautkan var count = 0 // merekodkan bilangan nod dalam senarai dikaitkan baru var kepala: nod <e>? = null // nod kepala senarai yang dipautkan baru sementara (temp.next?.value! = null) {// garis senarai yang dipautkan baru
        temp = temp.next !!

        sementara (temp2.next?.Value! = null) {// traversal list2
            temp2 = temp2.next !!
            jika (cmp.compare (temp.value, temp2.value) == 0) {// Cari elemen persimpangan var novo = deleteNode (temp) // padam nod dari list1 if (list! = null) {//
                    list.next = novo
                }
                Senarai = novo // Kemas kini kiraan nod ekor senarai baru yang dipautkan // tambah satu jika (count == 1) {// jika nod pertama, tetapkan senarai nod kepala.previous = null
                    kepala = senarai
                }

                DeletEnode (Temp2) // Padam node Break dari List2; // Setelah mencari elemen persimpangan, lompat keluar dari gelung dalaman}

        }
        temp2 = list2 // Setelah gelung dalaman selesai, tetapkan semula penunjuk Temp2 dan mula melintasi lagi dari kepala List2}


    kembali kepala // kembali ke nod kepala senarai yang dipautkan baru}

FUN <e> DeletEnode (Node: Node <e>): Node <e> {
    var prev = node.previous
    var seterusnya = node.next

    sementara (seterusnya! = null && next.value == node.value) {// Hilangkan elemen pendua seterusnya = next.next
    }


    jika (prev! = null) {
        prev.next = Seterusnya
    }
    jika (seterusnya! = null) {
        Next.Previous = Prev
    }

    Node kembali
}</e></e></e></e></e></e></e></e></e></e>

Penjelasan kod

1. Fungsi persimpangan:
   • Memulakan Senarai untuk Null untuk membina senarai persimpangan baru.
   • Gunakan temp dan temp2 untuk melangkah ke atas List1 dan List2 masing -masing.
   • Apabila cmp.compare (temp.value, temp2.value) == 0, ini bermakna elemen persimpangan telah dijumpai.
   • Hubungi fungsi DeletEnode untuk memadam nod yang sepadan dari List1 dan List2.
   • Tambah nod yang dipadam ke senarai persimpangan baru.
   • Mengekalkan nod kepala dan ekor senarai yang dipautkan baru.
   • Kembali ke nod kepala senarai yang dipautkan baru.
2. Fungsi DeletEnode:
   • Padam nod yang ditentukan dari senarai yang dipautkan.
   • Kemas kini petunjuk seterusnya dan sebelumnya dari nod depan dan belakang nod yang dipadam.
   • Logik deduplikasi juga dimasukkan ke dalam fungsi untuk memastikan unsur -unsur pendua dipadam.

Perkara yang perlu diperhatikan

• Pelaksanaan ini mengandaikan bahawa kedua -dua senarai dikaitkan input List1 dan List2 disusun.
• Fungsi DeletEnode akan mengubah suai senarai yang dipautkan asal.
• Pelaksanaan ini menggunakan semula nod List1 untuk membina senarai persimpangan baru.
• Situasi sempadan perlu dikendalikan dengan baik, seperti senarai yang dipautkan kosong.
• Oleh kerana senarai yang dipautkan adalah gelung, anda perlu memberi perhatian kepada keadaan gelung semasa traversal untuk mengelakkan gelung tak terhingga.

Meringkaskan

Melalui kod dan penjelasan di atas, kami berjaya melaksanakan fungsi mengira persimpangan dua senarai yang disusun di Kotlin dan memadamkan elemen senarai yang dipautkan asal. Penyelesaian ini dengan cekap menggunakan ciri -ciri senarai yang disusun, dan menyedari pengiraan persimpangan dan pengubahsuaian senarai berkaitan asal dengan memadam nod. Saya harap artikel ini dapat membantu anda memahami dan menggunakan pengetahuan yang relevan mengenai operasi senarai yang dipautkan.

Atas ialah kandungan terperinci Cari persimpangan dua senarai yang disusun di Kotlin dan padamkan elemen senarai yang berkaitan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!