Bahagian Dalaman LinkedList
Terokai struktur nod dua pautan LinkedList dan profil kerumitan masanya.
Bahagian Dalaman LinkedList ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.
Dalaman LinkedList
LinkedList ialah senarai berpaut ganda: setiap nod menyimpan rujukan kepada nod sebelumnya dan seterusnya, serta nilai elemen. Tidak seperti ArrayList, tiada tatasusunan sokongan — memori diperuntukkan bagi setiap nod.
class Node<T> {
T data;
Node<T> prev;
Node<T> next;
Node(T data) { this.data = data; }
}Profil Kerumitan Masa
Ciri prestasi LinkedList berbeza dengan ketara daripada ArrayList:
- addFirst / addLast: O(1)
- get(indeks): O(n) — mesti menelusuri dari kepala atau ekor
- remove(indeks): O(n) untuk mencari, kemudian O(1) untuk menanggalkan pautan
- Penelusuran menggunakan pengulang: O(n)
Gunakan LinkedList apabila anda memerlukan penyisipan yang kerap pada kepala atau ekor, bukan capaian rawak.
Mencipta dan Menelusuri LinkedList
Mencipta LinkedList dan melakukan lelaran mengikut antara muka List yang sudah anda ketahui. Perbezaannya ialah struktur dalaman.
import java.util.LinkedList;
LinkedList<String> list = new LinkedList<>();
list.add("Alice");
list.add("Bob");
list.add("Carol");
for (String name : list) {
System.out.println(name);
}
System.out.println("First: " + list.getFirst()); // Alice
System.out.println("Last: " + list.getLast()); // CaroladdFirst, addLast, removeFirst, removeLast
LinkedList mendedahkan operasi kepala dan ekor yang tidak ditawarkan oleh ArrayList dengan cekap:
LinkedList<Integer> nums = new LinkedList<>();
nums.addLast(10); // [10]
nums.addLast(20); // [10, 20]
nums.addFirst(5); // [5, 10, 20]
System.out.println(nums.removeFirst()); // 5 → [10, 20]
System.out.println(nums.removeLast()); // 20 → [10]Nyahpautan Node: Pemadaman O(1) Selepas Menemukannya
Setelah anda mempunyai rujukan kepada nod melalui pengulang, penyingkiran ialah O(1) kerana hanya penuding seterusnya dan sebelumnya perlu dikemas kini — tiada pengalihan elemen seperti dalam ArrayList.
import java.util.*;
LinkedList<String> tasks = new LinkedList<>(List.of("A","B","C","D"));
Iterator<String> it = tasks.iterator();
while (it.hasNext()) {
String t = it.next();
if (t.equals("B") || t.equals("D")) {
it.remove(); // O(1) unlink
}
}
System.out.println(tasks); // [A, C]Overhed Memori berbanding ArrayList
Setiap nod LinkedList membawa dua rujukan tambahan (sebelumnya, seterusnya) serta rujukan elemen — kira-kira 48 bait bagi setiap entri pada JVM 64-bit. ArrayList hanya menyimpan rujukan elemen (8 bait) dalam tatasusunan bersebelahan.
Untuk set data besar yang banyak dibaca, ArrayList biasanya lebih mesra ingatan cache dan menggunakan kurang memori.
Operasi Baris Dua Hujung: Tindanan dan Baris Gilir
LinkedList melaksanakan antara muka Deque, menjadikannya boleh digunakan sebagai tindanan dan juga baris gilir.
import java.util.LinkedList;
import java.util.Deque;
// As a Queue (FIFO)
Deque<String> queue = new LinkedList<>();
queue.offer("first");
queue.offer("second");
System.out.println(queue.poll()); // first
// As a Stack (LIFO)
Deque<String> stack = new LinkedList<>();
stack.push("bottom");
stack.push("top");
System.out.println(stack.pop()); // topGambaran Keseluruhan PriorityQueue
PriorityQueue ialah baris gilir berasaskan timbunan yang elemen terkecilnya (mengikut susunan semula jadi atau pembanding) sentiasa dikeluarkan dahulu. Ia NOT disokong oleh senarai berpaut — sebaliknya menggunakan tatasusunan timbunan binari.
import java.util.PriorityQueue;
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(40);
pq.offer(10);
pq.offer(25);
System.out.println(pq.poll()); // 10 (smallest)
System.out.println(pq.poll()); // 25
System.out.println(pq.poll()); // 40PriorityQueue dengan Pembanding Tersuai
Berikan Comparator untuk menterbalikkan susunan atau mengisih mengikut medan tersuai:
import java.util.*;
record Task(String name, int priority) {}
PriorityQueue<Task> tasks = new PriorityQueue<>(
Comparator.comparingInt(Task::priority).reversed() // highest first
);
tasks.offer(new Task("Low", 1));
tasks.offer(new Task("High", 10));
tasks.offer(new Task("Med", 5));
while (!tasks.isEmpty()) {
System.out.println(tasks.poll().name());
}
// High, Med, LowMemilih LinkedList berbanding ArrayList
Peraturan umum:
- Gunakan ArrayList untuk capaian rawak, lelaran dan kebanyakan senario.
- Gunakan LinkedList apabila anda memerlukan penyisipan atau penyingkiran O(1) yang kerap pada kedua-dua hujung dan tidak memerlukan capaian berdasarkan indeks.
- Gunakan PriorityQueue apabila anda memerlukan pemprosesan tersusun (penjadualan tugas, algoritma Dijkstra).
Perangkap Lazim
Elakkan memanggil get(i) dalam gelung pada LinkedList — jumlah kerumitannya ialah O(n²):
LinkedList<Integer> list = new LinkedList<>();
for (int i = 0; i < 10000; i++) list.add(i);
// BAD: O(n^2) — each get(i) traverses from head
for (int i = 0; i < list.size(); i++) {
int val = list.get(i); // slow!
}
// GOOD: O(n) — use iterator
for (int val : list) {
// process val
}Semakan Pantas
Operasi LinkedList manakah yang mempunyai kerumitan O(1) tanpa mengira saiz senarai?
Imbas Kembali: LinkedList dan Baris Dua Hujung
Perkara penting:
- LinkedList ialah senarai berpaut ganda dengan operasi kepala dan ekor O(1)
- Capaian rawak (mendapatkan atau menetapkan mengikut indeks) ialah O(n)
- Melaksanakan Deque — boleh digunakan sebagai tindanan atau baris gilir
- PriorityQueue menyediakan pemprosesan yang disusun mengikut timbunan
- Utamakan ArrayList untuk kebanyakan kegunaan; LinkedList cemerlang bagi perubahan kerap pada kepala atau ekor
Pelajari Java dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 104
- Pelajaran
- 374
Soalan Lazim
Adakah pelajaran “Bahagian Dalaman LinkedList” percuma?
Ya — teks penuh “Bahagian Dalaman LinkedList” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Bahagian Dalaman LinkedList”?
Terokai struktur nod dua pautan LinkedList dan profil kerumitan masanya. Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Java Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.
Berapa lamakah pelajaran “Bahagian Dalaman LinkedList” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?
Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Bahagian Dalaman LinkedList
- Operasi Deque: Timbunan dan Baris Gilir
- Pertukaran antara LinkedList dan ArrayList
- PriorityQueue untuk Pemprosesan Teratur