Artikel ini membagikan kode yang relevan untuk Java untuk mengimplementasikan daftar yang terkait tunggal dan daftar tertaut dua arah untuk referensi Anda. Konten spesifiknya adalah sebagai berikut
Java mengimplementasikan daftar tertaut tunggal:
kode paket; kelas node {node next; data int; node publik (data int) {this.data = data; }} class linkList {node pertama; // head public linklist () {this.first = null; } public void addNode (node no) {No.next = first; pertama = tidak; // Tambahkan head} public void delectNode () {node n = first.next; pertama = null; First = n; // hapus di head} // hapus posisi yang ditentukan nomor int publik () {int count = 1; // Lihat berapa banyak elemen yang ada node nd = pertama; while (nd.next! = null) {nd = nd.next; Count ++; } jumlah pengembalian; } public void delectexact (int n) {// hapus posisi yang ditentukan jika (n> 1) {int count = 1; Node de = pertama; while (count <n-1) {de = de.next; Count ++; } de.next = de.next.next; } else first = first.next; } public void addexact (int n, node nd) {if (n> 1) // Tambahkan posisi yang ditentukan {int count = 1; Node de = pertama; while (count <n-1) {de = de.next; Count ++; } nd.next = de.next; de.next = nd; } else first = first.next; } public int findNode (int n) {int count = 1; // Temukan posisi yang sesuai dengan node node de = pertama; while (de.data! = n) {de = de.next; Count ++; if (de == null) {return -1; }} return count; } public void print () {node no = first; // cetak semua sementara (tidak! = null) {System.out.println (No.Data); No = No.Next; }}} kelas publik TextNode {public static void main (string [] args) {linklist ll = new LinkList (); ll.addnode (node baru (12)); ll.addnode (node baru (15)); ll.addnode (node baru (18)); ll.addnode (node baru (19)); ll.addnode (node baru (20)); /*System.out.println(ll.first.data); ll.delectnode (); System.out.println (ll.first.data);*/ system.out.println (ll.number ()); ll.delectexact (3); ll.addexact (3, node baru (100)); System.out.println (ll.number ()); // ll.print (); System.out.println (ll.findnode (112)); }}Java mengimplementasikan daftar tertaut dua arah:
kelas publik doublelink {public static void main (string [] args) {node2 no = new node2 (5); Tidak. No.Addright (Node2 baru (7)); /*no.print (); No.print2 ();*/ No.Addexact2 (1, node baru2 (8)); No. Print (); System.out.println ("-------------------"); No.print2 (); }} class node2 {public node2 pertama; akhir node2 publik; Node 2 publik kiri; Node2 Public Right; int data = 0; node2 publik (int n) {first = this; end = ini; first.data = n; } // Tambahkan public void dari head addleft (node2 sebelumnya) {first.left = sebelumnya; Sebelumnya. Pertama; pertama = sebelumnya; } // Tambahkan public void dari ekor addright (node2 setelah) {end.right = setelah; setelah. Left = end; akhir = setelah; } // Masukkan jumlah public void addexact (int n, node2 no) {int count = 0; if (n == 0) {addleft (no); } else {node2 f = pertama; while (true) {f = f.right; Count ++; if (count == n) {// Ini adalah perubahan dalam menunjuk empat pointer no.left = f.left; f.left.right = tidak; // first.left = no; No.right = f; F.Left = Tidak; merusak; }}}}} // Masukkan jumlah public void addexact2 (int n, node2 no) {int count = 0; if (n == 0) {addright (no); } else {node2 f = end; while (true) {f = f.left; Count ++; if (count == n) {no.left = f; No.right = f.right; f.right.left = tidak; f.right = tidak; merusak; }}}}} // Positif traversal public void print () {System.out.println (first.data); while (first.right! = null) {System.out.println (first.right.data); pertama = pertama. } // System.out.println (end.data); } // Reverse Order Traversal public void print2 () {System.out.println (end.data); while (end.left! = null) {System.out.println (end.left.data); end = end.left; }}}/*Perlu dicatat bahwa setiap kali objek baru dimasukkan, Anda perlu memperhatikan perubahan penunjuk pointer. Pertama, menunjuk kedua sisi objek baru ini (kiri dan kanan), diikuti dengan menunjuk objek kiri ke kanan dan menunjuk objek kanan ke kiri. Menunjuk keempat pointer ini harus benar, jika tidak, hal itu dapat menyebabkan ketidakmampuan untuk menerapkan traversal urutan positif atau terbalik. *//*Bandingkan daftar tunggal yang ditautkan, daftar tertaut tunggal hanya dapat dilalui dari satu arah karena hanya ada satu kepala, sedangkan daftar ditautkan dua arah memiliki kepala dan ekor. Itu dapat dilintasi dari kepala * atau dari ekor. Selain itu, karena salah satu objek memiliki pointer dalam dua arah, ia dapat memperoleh objek * di sebelah kiri dan objek di sebelah kanan. * Tetapi untuk daftar tunggal yang terkait, karena hanya ada satu arah, mereka hanya bisa ke kiri atau kanan. Saat menambahkan objek, Anda juga dapat menambahkannya dari awal atau dari akhir. * Jika satu daftar yang ditautkan perlu menambahkan dua arah, jarang, atau tidak, karena hanya memiliki pointer ke satu arah ke kiri atau kanan*, sementara setiap objek dari daftar ditautkan dua arah memiliki pointer ke dua arah, yang tidak lebih fleksibel, tetapi ini juga memiliki kerugian, karena dengan cara ini, setiap objek* akan berisi dua pointer, yang juga akan mengonsumsi lebih banyak. * * *//Di atas adalah semua tentang artikel ini, saya harap akan sangat membantu bagi semua orang untuk belajar pemrograman Java.