Java Linked Listed Operation: Daftar Tautan Lingkaran
Contoh analisis utama:
1. DAFTAR TINGKAT SINGLED Daftar Berulang
2. Daftar Daftar Berulang Double-Linked
Di antara mereka, simpul daftar tunggal dan kelas node daftar double-linked dan antarmuka icommoperate <T> konsisten dengan artikel sebelumnya, dan tidak akan dibahas di sini. Referensi: Java Linked Listed Operations: Single-Linked List dan Double-Linked List //www.vevb.com/article/95113.htm
1. DAFTAR TINGKAT SINGLED Daftar Berulang
Paket LinkListTest; import java.util.hashmap; import java.util.map; kelas publik singleCyclelinklist mengimplementasikan Icommoperate <snode> {private snode head = snode baru ("head"); // pointer header publik, tidak berubah setelah deklarasi ukuran int pribadi = 0; int int getsize () {return this.size; } / * * Masukkan daftar yang ditautkan, setiap kali dimasukkan ke ujung, standar untuk menentukan apakah ujungnya menunjuk selanjutnya ke kepala * * / @override public boolean insertNode (node snode) {boolean flag = false; initlinklist (); // inisialisasi daftar tertaut if (this.size == 0) {// Daftar ditautkan kosong this.head.setNextNode (node); node.setNextNode (this.head); } else {snode arus = this.head; while (current.getNextNode ()! = this.head) {// temukan simpul akhir arus = current.getNextNode (); } current.setNextNode (node); node.setNextNode (this.head); // Ikuti daftar tertaut yang buruk, simpul ekor menunjuk ke kepala} this.size ++; bendera = true; pengembalian bendera; } / * * Masukkan posisi yang ditentukan dari daftar yang ditautkan, mulai dari 1, dan POS lebih besar dari ukuran, masukkan di akhir daftar yang ditautkan * * / @Override Public Boolean InsertPoSnode (int pos, snode node) {boolean flag = true; Snode arus = this.head.getNextNode (); initlinkList (); // menginisialisasi daftar yang ditautkan jika (this.size == 0) {// Daftar yang ditautkan kosong ini. node.setNextNode (this.head); // Ikuti daftar tertaut yang buruk, simpul ekor menunjuk untuk memimpin this.size ++; } lain jika (this.size <pos) {// Posisi POS lebih besar dari panjang daftar yang ditautkan, masukkan sisipan ujung (node); } else if (pos> 0 && pos <= this.size) {// simpul dalam daftar tertaut // 1. Temukan node dan simpul sebelumnya yang akan dimasukkan, dan node akan dimasukkan antara dua node int find = 0; Snode prenode = this.head; // simpul depan snode currentNode = arus; // simpul saat ini (temukan <pos-1 && currentNode! = This.head) {prenode = arus; // simpul depan bergerak ke belakang currentNode = currentNode.getNextNode (); // Node saat ini dipindahkan ke belakang Find ++; if (temukan <pos-1 && currentNode! = this.head) {// node belum selesai mencari node, dan simpul dipindahkan mundur arus = current.getNextNode (); }} // System.out.println (prenode); // System.out.println (currentNode); // 2. Masukkan node prenode.setNextNode (node); node.setNextNode (currentNode); this.size ++; } else {System.out.println ("Kesalahan informasi posisi"); bendera = false; } mengembalikan bendera; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); }} / * * Tentukan node pos dari daftar yang ditautkan dan hapus simpul yang sesuai. Metode: Temukan node depan dan belakang untuk menghapus, menghapus, dan subskrip dimulai dari 1 * */ @Override public boolean deletenode (int pos) {boolean flag = false; Snode arus = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Kesalahan informasi posisi atau tidak ada informasi dalam daftar tertaut"); } else {// 1. Temukan node depan dan belakang untuk menghapus int find = 0; Snode prenode = this.head; // node depan snode nextNode = current.getNextNode (); // node belakang while (temukan <pos-1 && nextNode! = This.head) {prenode = current; // simpul depan dipindahkan kembali nextNode = nextNode.getNextNode (); // simpul belakang dipindahkan kembali Find ++; if (temukan <pos-1 && nextNode! = this.head) {// simpul depan belum selesai, "simpul depan" belakang dipindahkan kembali arus = current.getNextNode (); }} // System.out.println (prenode); // system.out.println (nextNode); // 2. Hapus node prenode.setNextNode (nextNode); System.gc (); // daur ulang dan hapus node this.size--; bendera = true; } mengembalikan bendera; } / * * Tentukan node pos dari daftar tertaut, ubah simpul yang sesuai, dan subskrip dimulai dari 1 * * / @Override public boolean updateNode (int pos, peta <string, objek> peta) {boolean flag = false; Snode node = getNode (pos, peta); // Dapatkan simpul di pos yang sesuai jika (node! = Null) {string data = (string) map.get ("data"); node.setData (data); bendera = true; } mengembalikan bendera; } / * * Temukan node pos dari daftar tertaut yang ditentukan, dan subskrip dimulai dari 1 * * / @Override public snode getNode (int pos, peta <string, objek> peta) {snode arus = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Informasi posisi salah atau daftar yang ditautkan tidak ada"); kembali nol; } int find = 0; while (temukan <pos-1 && current! = this.head) {current = current.getNextNode (); Temukan ++; } return arus; } / * * Cetak Daftar Tertaut * * / @Override public void printlink () {int length = this.size; if (length == 0) {System.out.println ("Daftar tertaut kosong!"); kembali ; } Snode arus = this.head.getNextNode (); System.out.println ("Jumlah total node:" + panjang + "yang"); int find = 0; while (saat ini! = this.head) {System.out.println ("th" + (++ find) + "node:" + arus); current = current.getNextNode (); }} public static void main (string [] args) {singleCyclelinkList scll = singleCyclelinkList baru (); Snode node1 = snode baru ("node1"); Snode node2 = snode baru ("node2"); Snode node3 = snode baru ("node3"); Snode node4 = snode baru ("node4"); Snode node5 = snode baru ("node5"); Snode node6 = snode baru ("masukkan posisi yang ditentukan"); // scll.insertposnode (scll.getsize ()+1, node1); // scll.insertposnode (scll.getsize ()+1, node2); // scll.insertPosNode (scll.getsize ()+node2); // scll.insertPosNode (scll.getsize ()+1); scll.insertposnode (scll.getsize ()+1, node3); // scll.insertposnode (scll.getsize ()+1, node4); // scll.insertposnode (scll.getsize ()+1, node5); scll.insertnode (node1); scll.insertnode (node2); scll.insertnode (node3); scll.insertnode (node4); scll.insertnode (node5); System.out.println ("*****************************"); scll.printlink (); System.out.println ("********************** Dapatkan Node Daftar Tertaut yang ditentukan *******************************"); int pos = 2; System.out.println ("Dapatkan data posisi"+pos+"dari daftar tertaut:"+scll.getnode (pos, null)); System.out.println ("*****************************"); int pos1 = 3; System.out.println ("Masukkan data ke dalam node"+pos1+":"); scll.insertposnode (pos1, node6); scll.printlink (); System.out.println ("************************* Hapus simpul yang ditentukan dalam daftar tertaut ******************************"); int pos2 = 3; System.out.println ("Delete"+Pos2+"node:"); scll.deletenode (pos2); scll.printlink (); System.out.println ("*************************** int pos3 = 3; System.out.println ("Modifikasi"+pos3+"node:"); Peta <String, Object> MAP = HashMap baru <> (); peta.put ("data", "Ini adalah tes"); scll.updatenode (pos3, peta); scll.printlink (); }}2. Daftar Daftar Berulang Double-Linked
Paket LinkListTest; import java.util.hashmap; import java.util.map; kelas publik doublecyclelinklist mengimplementasikan icommoperate <dnode> {private dnode head = dnode baru ("head"); // pointer header publik, tidak berubah setelah deklarasi ukuran int pribadi = 0; // Catat jumlah node dari daftar publik tertaut int getsize () {return this.size; } / * * Masukkan daftar yang ditautkan, setiap kali dimasukkan ke ujung, standar untuk menentukan apakah ujungnya menunjuk selanjutnya ke kepala * * / @Override public boolean insertNode (node dnode) {boolean flag = false; initlinklist (); // inisialisasi daftar dnode dnode linked = this.head; if (this.size == 0) {// daftar ditautkan kosong this.head.setNextNode (node); node.setPriornode (this.head); node.setNextNode (this.head); } else {// node dalam daftar tertaut while (current.getNextNode ()! = this.head) {// temukan node akhir arus = current.getNextNode (); } current.setNextNode (node); node.setPriornode (saat ini); node.setNextNode (this.head); // Arahkan kembali daftar tertaut yang buruk, simpul ekor menunjuk ke kepala} this.size ++; bendera = true; pengembalian bendera; } / * * Masukkan posisi yang ditentukan dari daftar yang ditautkan, mulai dari 1, dan POS lebih besar dari ukuran, masukkan ujung daftar yang ditautkan * * / @Override Public Boolean InsertPosNode (int pos, node dnode) {boolean flag = true; initlinklist (); // inisialisasi daftar dnode tertaut saat ini = this.head.getNextNode (); if (this.size == 0) {// Daftar yang ditautkan kosongkan this.head.setNextNode (node); node.setPriornode (this.head); node.setNextNode (this.head); this.size ++; } lain if (pos> this.size) {// Posisi POS lebih besar dari panjang daftar yang ditautkan, masukkan ujungnya insertNode (node); } else if (pos> 0 && pos <= this.size) {// simpul dalam daftar tertaut // 1. Temukan simpul POS yang akan dimasukkan, masukkan posisi POS Node saat ini Find = 0; while (temukan <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); Temukan ++; } // 2. Masukkan node if (current.getNextNode () == this.head) {// node tail node.setPriornode (saat ini); node.setNextNode (this.head); current.setNextNode (node); } else if (current.getNextNode ()! = this.head) {// node node intermediate.setPriornode (current.getPriornode ()); node.setNextNode (saat ini); current.getPriornode (). setnextNode (node); current.setPriornode (node); } this.size ++; } else {System.out.println ("Kesalahan informasi posisi"); bendera = false; } mengembalikan bendera; } private void initlinkList () {if (size == 0) {this.head.setNextNode (this.head); this.head.setPriornode (this.head); }} / * * Tentukan node pos dari daftar yang ditautkan dan hapus simpul yang sesuai. Metode: Temukan penghapusan simpul depan dan belakang dari node yang akan dihapus, dan subskrip dimulai dari 1 * */ @Override public boolean deletenode (int pos) {boolean flag = false; Dnode arus = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Informasi posisi salah atau daftar yang ditautkan tidak ada"); } else {// 1. Temukan node POS lokasi yang akan dihapus int find = 0; while (temukan <pos-1 && current.getNextNode ()! = this.head) {current = current.getNextNode (); Temukan ++; } // 2. Hapus node if (current.getNextNode () == this.head) {// node tail current.getPriornode (). SetnextNode (this.head); } else if (current.getNextNode ()! = this.head) {// node intermediate current.getPriornode (). setnextNode (current.getNextNode ()); current.getNextNode (). setPrioNnode (current.getPriornode ()); } System.gc (); // daur ulang dan hapus node ini.Size--; bendera = true; } mengembalikan bendera; } / * * Tentukan node pos dari daftar tertaut, ubah node yang sesuai, dan subskrip dimulai dari 1 * * / @Override public boolean updateNode (int pos, peta <string, objek> peta) {boolean flag = false; Node dnode = getNode (pos, peta); if (node! = null) {string data = (string) map.get ("data"); node.setData (data); bendera = true; } mengembalikan bendera; } / * * Temukan node pos dari daftar tertaut yang ditentukan, dan subskrip dimulai dari 1 * * / @Override dnode publik getNode (int pos, peta <string, objek> peta) {dnode current = this.head.getNextNode (); if (pos <= 0 || pos> this.size || current == this.head) {System.out.println ("Informasi posisi salah atau daftar yang ditautkan tidak ada"); kembali nol; } int find = 0; while (temukan <pos-1 && current! = this.head) {current = current.getNextNode (); Temukan ++; } return arus; } / * * Cetak Daftar Tertaut * * / @Override public void printlink () {int length = this.size; if (length == 0) {System.out.println ("Daftar tertaut kosong!"); kembali ; } Dnode arus = this.head.getNextNode (); int find = 0; System.out.println ("Jumlah total node:" + panjang + "yang"); while (saat ini! = this.head) {System.out.println ("th" + (++ find) + "satu node:" + saat ini); current = current.getNextNode (); }} public static void main (string [] args) {doublecyclelinklist dcll = doublecyclelinklist baru (); Dnode node1 = dnode baru ("node1"); Dnode node2 = dnode baru ("node2"); Dnode node3 = dnode baru ("node3"); Dnode node4 = dnode baru ("node4"); Dnode node5 = dnode baru ("node5"); Dnode node6 = dnode baru ("masukkan posisi yang ditentukan"); dcll.insertposnode (10, node1); dcll.insertposnode (10, node2); dcll.insertposnode (8, node3); dcll.insertposnode (88, node4); dcll.insertposnode (8, node5); // dcll.insertnode (node1); // dcll.insertnode (node2); // dcll.insertnode (node3); // dcll.insertnode (node4); // dcll.insertnode (node); System.out.println ("************************** Output Daftar Tertaut ***************************"); dcll.printlink (); System.out.println ("********************************"); int pos = 2; System.out.println ("Dapatkan data posisi"+pos+"dari daftar tertaut:"+dcll.getnode (POS, null)); System.out.println ("************************** Sisipkan node ke posisi yang ditentukan dari daftar tertaut ******************************"); int pos1 = dcll.getsize ()+1; System.out.println ("Masukkan data ke"+pos1+"node:"); dcll.insertposnode (pos1, node6); dcll.printlink (); System.out.println ("********************** Hapus Node Lokasi yang ditentukan dari daftar tertaut ******************************"); int pos2 = 7; System.out.println ("Delete"+Pos2+"node:"); dcll.deletenode (pos2); dcll.printlink (); System.out.println ("***********************************"); int pos3 = 3; System.out.println ("Ubah node"+pos3+":"); Peta <String, Object> MAP = HashMap baru <> (); peta.put ("data", "Ini adalah tes"); dcll.updatenode (pos3, peta); dcll.printlink (); }}Terima kasih telah membaca, saya harap ini dapat membantu Anda. Terima kasih atas dukungan Anda untuk situs ini!