Cara menyelesaikan: Ralat struktur data Java: Gelung senarai terpaut

Cara menyelesaikan: Ralat struktur data Java: gelung senarai terpaut

Pengenalan:
Dalam pengaturcaraan Java, senarai terpaut sering digunakan sebagai struktur data untuk menyimpan dan memanipulasi data. Walau bagaimanapun, kesilapan biasa kadangkala berlaku apabila berurusan dengan operasi senarai terpaut - gelung senarai terpaut. Kitaran senarai terpaut bermakna nod dalam senarai terpaut menghala ke nod sebelumnya atau nod seterusnya dalam senarai terpaut, menyebabkan senarai terpaut tidak dilalui dengan betul. Artikel ini meneroka cara menyelesaikan masalah ini dan menyediakan contoh kod.

Analisis masalah:
Gelung senarai terpaut biasanya disebabkan oleh rujukan nod senarai terpaut yang menunjuk ke lokasi yang salah. Ini mungkin disebabkan oleh ralat pengekodan, ralat logik atau sebab lain. Sebelum menyelesaikan masalah ini, mari kita lihat contoh kod:

class Node {
    int data;
    Node next;
    
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    Node head;
    
    public void add(int data) {
        Node newNode = new Node(data);
        
        if(head == null) {
            head = newNode;
        } else {
            Node current = head;
            
            while(current.next != null) {
                current = current.next;
            }
            
            current.next = newNode;
        }
    }
}

Kod di atas ialah pelaksanaan senarai terpaut yang mudah, yang mengandungi kelas Node untuk mewakili nod dan LinkedList< /code >Kelas mewakili senarai terpaut. Dalam kaedah <code>add, nod baharu akan ditambahkan pada penghujung senarai terpaut. Node类表示节点，以及一个LinkedList类表示链表。在add方法中，新节点会被添加到链表的末尾。

问题解决：
要解决链表循环的问题，我们需要检查链表中是否存在循环，并找到循环的位置。可以使用快慢指针的方法来实现。

快慢指针法的基本思想是将两个指针放在链表的头部，一个指针每次移动一步，另一个指针每次移动两步。如果链表中存在循环，则快指针最终将追上慢指针。

下面我们来修改LinkedList类的代码，添加一个hasCycle方法来检查链表是否存在循环：

public class LinkedList {
    Node head;
    
    public boolean hasCycle() {
        Node fast = head;
        Node slow = head;
        
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            
            if(fast == slow) {
                return true;
            }
        }
        
        return false;
    }
}

在hasCycle方法中，我们使用了快慢指针来检测链表中是否存在循环。如果存在循环，快慢指针最终会相遇，就说明链表中存在循环。

接下来，我们修改add方法，添加一个判断链表是否存在循环的逻辑：

public void add(int data) {
    Node newNode = new Node(data);
    
    if(hasCycle()) {
        throw new IllegalArgumentException("链表中存在循环");
    }
    
    if(head == null) {
        head = newNode;
    } else {
        Node current = head;
        
        while(current.next != null) {
            current = current.next;
        }
        
        current.next = newNode;
    }
}

在添加新节点之前，我们先调用hasCycle

Penyelesaian Masalah:

Untuk menyelesaikan masalah gelung senarai terpaut, kita perlu menyemak sama ada terdapat gelung dalam senarai terpaut dan mencari lokasi gelung. Ini boleh dicapai menggunakan penunjuk cepat dan perlahan.

Idea asas kaedah penunjuk cepat dan perlahan ialah meletakkan dua penunjuk di kepala senarai terpaut Satu penunjuk bergerak satu langkah pada satu masa, dan penunjuk yang lain menggerakkan dua langkah pada satu masa. Jika terdapat kitaran dalam senarai terpaut, penuding pantas akhirnya akan mengejar penuding perlahan.

Mari kita ubah suai kod kelas LinkedList dan tambahkan kaedah hasCycle untuk menyemak sama ada terdapat kitaran dalam senarai terpaut:

rrreee
• Dalam hasCycle kaedah , kami menggunakan penunjuk cepat dan perlahan untuk mengesan sama ada terdapat kitaran dalam senarai terpaut. Jika terdapat kitaran, penunjuk cepat dan perlahan akhirnya akan bertemu, menunjukkan bahawa terdapat kitaran dalam senarai terpaut.

Seterusnya, kami mengubah suai kaedah add dan menambah logik untuk menentukan sama ada terdapat kitaran dalam senarai terpaut: 🎜rrreee🎜Sebelum menambah nod baharu, kami terlebih dahulu memanggil hasCycle kaedah untuk mengesan Sama ada terdapat kitaran dalam senarai terpaut. Jika gelung wujud, buang pengecualian dan maklumkan pengguna. 🎜🎜Kesimpulan: 🎜Dengan menggunakan kaedah penunjuk cepat dan perlahan, kita boleh mengesan dengan berkesan sama ada terdapat kitaran dalam senarai pautan dan mengelakkannya apabila menambah nod. Artikel ini menyediakan contoh kod mudah, dengan harapan dapat membantu pembaca memahami dengan lebih baik dan menyelesaikan masalah gelung senarai terpaut. Sudah tentu, dalam pembangunan sebenar, kita juga perlu nyahpepijat dan mengoptimumkan mengikut keadaan tertentu untuk memastikan ketepatan dan prestasi kod. 🎜🎜Rujukan: 🎜🎜🎜[https://leetcode.com/problems/linked-list-cycle/](https://leetcode.com/problems/linked-list-cycle/)🎜🎜

Atas ialah kandungan terperinci Cara menyelesaikan: Ralat struktur data Java: Gelung senarai terpaut. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!