ตารางการเชื่อมโยงเดียวแบบจำลอง
ตารางเชิงเส้น:
ตารางเชิงเส้น (เรียกอีกอย่างว่าตารางลำดับ) เป็นโครงสร้างข้อมูลพื้นฐานที่ง่ายที่สุดและใช้กันมากที่สุด
ความสัมพันธ์ระหว่างองค์ประกอบข้อมูลในตารางเชิงเส้นเป็นความสัมพันธ์แบบหนึ่งต่อหนึ่งนั่นคือยกเว้นองค์ประกอบข้อมูลแรกและสุดท้ายองค์ประกอบข้อมูลอื่น ๆ เชื่อมต่อกับจุดสิ้นสุด
โครงสร้างเชิงตรรกะของตารางเชิงเส้นนั้นง่ายซึ่งใช้งานง่ายและใช้งานได้ง่าย
ในการใช้งานจริงจะใช้ตารางเชิงเส้นในรูปแบบของตารางเชิงเส้นพิเศษเช่นสแต็คคิวและสตริง
ลักษณะพื้นฐานของโครงสร้างเชิงเส้นคือ:
1. จะต้องมี "องค์ประกอบแรก" ที่ไม่ซ้ำกันในคอลเลกชัน;
2. จะต้องมี "องค์ประกอบสุดท้าย" ที่ไม่ซ้ำกันในคอลเลกชัน
3. ยกเว้นองค์ประกอบสุดท้ายมีผู้สืบทอดที่ไม่ซ้ำกัน (รายการล่าสุด);
4. ยกเว้นองค์ประกอบแรกมีไดรฟ์ด้านหน้าที่เป็นเอกลักษณ์ (ชิ้นส่วนด้านหน้า)
รายการที่เชื่อมโยง: รายการที่เชื่อมโยง
รายการที่เชื่อมโยงคือโครงสร้างการจัดเก็บข้อมูลที่ไม่ต่อเนื่องและไม่ต่อเนื่องบนหน่วยเก็บข้อมูลทางกายภาพ ลำดับตรรกะขององค์ประกอบข้อมูลคือรายการข้อมูลแต่ละรายการที่นำมาใช้ผ่านลำดับการเชื่อมโยงตัวชี้ในรายการที่เชื่อมโยงนั้นมีอยู่ใน "จุดเชื่อมโยง"
ลิงค์เป็นวัตถุของคลาสและประเภทนี้สามารถเรียกได้ว่าลิงก์ มีลิงก์ที่คล้ายกันมากมายในรายการที่เชื่อมโยงและแต่ละลิงก์มีฟิลด์ถัดไปอ้างอิงถึงลิงค์ถัดไป
วัตถุรายการที่เชื่อมโยงนั้นมีการอ้างอิงถึงโหนดลิงค์แรก (หากไม่มีก่อนจะไม่สามารถอยู่ได้)
รายการที่เชื่อมโยงไม่สามารถเข้าถึงรายการข้อมูลโดยตรงเช่นอาร์เรย์ (โดยใช้ตัวห้อย) แต่จำเป็นต้องวางตำแหน่งกับความสัมพันธ์ระหว่างข้อมูลนั่นคือเข้าถึงลิงก์ถัดไปที่อ้างอิงโดยโหนดลิงก์และจากนั้นข้อมูลถัดไปจนกว่าข้อมูลที่ต้องการจะเข้าถึง การดำเนินการเหล่านี้ต้องการค่าเฉลี่ยของการค้นหาครึ่งหนึ่งของโหนดในรายการที่เชื่อมโยงโดยมีประสิทธิภาพของ O (n)
รายการที่เชื่อมโยงเดียว:
ตารางเชิงเส้นแสดงโดย "ลำดับของโหนด" และเรียกว่ารายการที่เชื่อมโยงเชิงเส้น (รายการลิงค์เดียว)
มันเป็นโครงสร้างข้อมูลการเข้าถึงโซ่โดยใช้ชุดหน่วยเก็บข้อมูลที่มีที่อยู่โดยพลการเพื่อจัดเก็บองค์ประกอบข้อมูลในตารางเชิงเส้น (ชุดของเซลล์หน่วยความจำนี้สามารถต่อเนื่องหรือไม่ต่อเนื่อง)
โครงสร้างของโหนดลิงก์:
ข้อมูลเขตข้อมูลข้อมูลที่เก็บค่าโหนด ฟิลด์ตัวชี้ (ฟิลด์โซ่) ที่เก็บการอ้างอิงโหนดถัดไป
รายการที่เชื่อมโยงเชื่อมโยงโหนด n ของตารางเชิงเส้นเข้าด้วยกันในลำดับตรรกะของพวกเขาผ่านโดเมนลิงค์ของแต่ละโหนด
รายการที่เชื่อมโยงกับฟิลด์ลิงค์เดียวต่อโหนดเรียกว่ารายการลิงค์เดียว ในทิศทางเดียวมีการอ้างอิงถึงก้อนที่ตามมาเท่านั้น
/*** รายการที่เชื่อมโยงเดียว: วิธีการแทรกส่วนหัวและออกก่อน* ด้านซ้ายของรายการที่เชื่อมโยงเรียกว่าหัวโซ่และด้านขวาเรียกว่าหางโซ่ * วิธีการแทรกส่วนหัวเพื่อสร้างรายการที่เชื่อมโยงเดียวนั้นได้มาจากการดูปลายด้านขวาของรายการที่เชื่อมโยงตามที่ได้รับการแก้ไขและรายการที่เชื่อมโยงยังคงขยายไปทางซ้าย * สิ่งแรกที่มาจากวิธีการแทรกส่วนหัวคือโหนดหาง * @author stone */ คลาสสาธารณะ SingleLinkedList <T> {Private Link <T> ก่อน; // โหนดแรกโหนด SingleLinkedList () {} บูลีนสาธารณะ isempty () {return first == null; } โมฆะสาธารณะ INSERTFIRST (ข้อมูล t) {// แทรกลงในหัวของลิงค์โซ่ <T> newLink = ลิงก์ใหม่ <T> (ข้อมูล); newLink.next = ก่อน; // ถัดไปของโหนดใหม่ชี้ไปที่โหนดก่อนหน้า first = newLink; } ลิงค์สาธารณะ <t> deleteFirst () {// ลบลิงก์ส่วนหัวของห่วงโซ่ <t> temp = ก่อน; first = first.next; // เปลี่ยนโหนดแรกเพื่อส่งคืนอุณหภูมิ; } ลิงค์สาธารณะ <t> ค้นหา (t t) {ลิงก์ <t> find = first; ในขณะที่ (ค้นหา! = null) {ถ้า (! find.data.equals (t)) {find = find.next; } else {break; }} return find; } ลิงก์สาธารณะ <t> ลบ (t t) {ถ้า (isempty ()) {return null; } else {ถ้า (first.data.equals (t)) {link <t> temp = ก่อน; first = first.next; // เปลี่ยนโหนดแรกเป็นอุณหภูมิส่งคืนโหนดถัดไป }} ลิงก์ <t> p = ก่อน; ลิงก์ <t> q = ก่อน; ในขณะที่ (! p.data.equals (t)) {ถ้า (p.next == null) {// ลงชื่อสมัครใช้จนถึงตอนท้ายของโซ่ แต่ไม่พบการส่งคืน null; } else {q = p; p = p.next; }} q.next = p.next; กลับ P; } โมฆะสาธารณะ displayList () {// transpole system.out.println ("รายการ (ครั้งแรก-> สุดท้าย):"); ลิงก์ <t> current = ก่อน; ในขณะที่ (ปัจจุบัน! = null) {current.displaylink (); current = current.next; }} โมฆะสาธารณะ displayListreverse () {// ลิงค์ข้ามผกผัน <t> p = แรก, Q = first.next, t; ในขณะที่ (q! = null) {// ตัวชี้กลับด้านลำดับข้อมูลที่ผ่านการสำรวจจะย้อนกลับ t = q.next; // no3 ถ้า (p == ก่อน) {// เมื่อเป็นส่วนหัวดั้งเดิม,. next ของหัวควรว่าง p.next = null; } q.next = p; // no3 -> no1 ตัวชี้ย้อนกลับ p = q; // start คือ reverse q = t; // no3 start} // ใน IF ในลูปด้านบนก่อนหน้านี้จะว่างเปล่าและเมื่อ q เป็นโมฆะและไม่ดำเนินการลูป p คือรายการข้อมูลส่วนใหญ่ดั้งเดิม หลังจากการผกผัน P จะถูกกำหนดให้เป็นอันดับแรก = p; DisplayList (); } class link <t> {// link point t data; // ลิงค์ฟิลด์ข้อมูล <t> ถัดไป; // ตัวชี้ที่ตามมาลิงก์โดเมนโซ่โหนด (ข้อมูล t) {this.data = data; } void displayLink () {system.out.println ("ข้อมูลคือ" + data.toString ()); }} โมฆะคงที่สาธารณะหลัก (สตริง [] args) {singlelinkedList <integer> list = new SingleLinkedList <integer> (); list.insertfirst (33); list.insertfirst (78); list.insertfirst (24); list.insertfirst (22); list.insertfirst (56); list.displaylist (); list.deletefirst (); list.displaylist (); System.out.println ("ค้นหา:" + list.find (56)); System.out.println ("ค้นหา:" + list.find (33)); System.out.println ("ลบค้นหา:" + list.delete (99)); System.out.println ("ลบค้นหา:" + list.delete (24)); list.displaylist (); System.out.println ("--- ย้อนกลับ ----"); list.displaylistreverse (); -พิมพ์
รายการ (ครั้งแรก-> สุดท้าย): ข้อมูลคือ 56 ข้อมูลคือ 22 ข้อมูลคือ 24 ข้อมูลคือ 78 ข้อมูลคือ 33 รายการ (แรก-> สุดท้าย): ข้อมูลคือ 22 ข้อมูลคือ 24 ข้อมูลคือ 78 ข้อมูลคือ 33 ค้นหา ค้นหา: linked_list.singlelinkedlist$link@17dfafd1 รายการ (ครั้งแรก-> สุดท้าย): ข้อมูลคือ 22 ข้อมูลคือ 78 ข้อมูลคือ 33 --- ย้อนกลับ --- รายการ (ครั้งแรก-> สุดท้าย): ข้อมูลคือ 33 ข้อมูลคือ 78 ข้อมูลคือ 22 ข้อมูลคือ 22
รายการที่เชื่อมโยงเดี่ยว: วิธีการแทรกหางกลับในครั้งแรก - หากปลายด้านซ้ายของรายการที่เชื่อมโยงได้รับการแก้ไขรายการที่เชื่อมโยงจะยังคงขยายไปทางขวาวิธีการสร้างรายการที่เชื่อมโยงนี้เรียกว่าวิธีการแทรกหาง
เมื่อสร้างรายการที่เชื่อมโยงด้วยวิธีการแทรกหางตัวชี้หัวจะได้รับการแก้ไขดังนั้นตัวชี้หางจะต้องตั้งค่าเพื่อขยายไปทางขวาของรายการที่เชื่อมโยง
สิ่งแรกที่มาจากวิธีการแทรกหางคือโหนดหัว
ระดับสาธารณะ SingleLinkedList2 <T> {Private Link <T> Head; // โหนดแรกโหนด SingleLinkedList2 () {} บูลีนสาธารณะ isempty () {return head == null; } โมฆะสาธารณะ InsertLast (t data) {// แทรกลิงค์ <t> newLink = ลิงก์ใหม่ <t> (ข้อมูล); if (head! = null) {link <t> nextp = head.next; if (nextp == null) {head.next = newLink; } else {link <t> hear = null; ในขณะที่ (nextp! = null) {rear = nextp; nextp = nextp.next; } rear.next = newLink; }} else {head = newLink; }} ลิงค์สาธารณะ <t> deletElast () {// ลบหางของลิงค์โซ่ <t> p = head; ลิงก์ <t> q = head; ในขณะที่ (p.next! = null) {// โหนดถัดไปของ p ไม่ว่างเปล่า q เท่ากับ purrent p (นั่นคือ q คือโหนดก่อนหน้าและ p คือโหนดถัดไป) เมื่อลูปสิ้นสุดลง q เท่ากับจุดสิ้นสุดสุดท้ายของห่วงโซ่ q = p; p = p.next; } // ลบ Q.Next = null; กลับ P; } ลิงค์สาธารณะ <t> ค้นหา (t t) {ลิงก์ <t> find = head; ในขณะที่ (ค้นหา! = null) {ถ้า (! find.data.equals (t)) {find = find.next; } else {break; }} return find; } ลิงก์สาธารณะ <t> ลบ (t t) {ถ้า (isempty ()) {return null; } else {ถ้า (head.data.equals (t)) {link <t> temp = head; head = head.next; // เปลี่ยนโหนดแรกเพื่อส่งคืนอุณหภูมิ; }} ลิงก์ <t> p = head; ลิงก์ <t> q = head; ในขณะที่ (! p.data.equals (t)) {ถ้า (p.next == null) {// หมายความว่าไม่พบ null ที่ส่งคืนไม่พบในตอนท้ายของห่วงโซ่; } else {q = p; p = p.next; }} q.next = p.next; กลับ P; } โมฆะสาธารณะ displayList () {// travel system.out.println ("รายการ (หัว-> สุดท้าย):"); ลิงก์ <t> current = head; ในขณะที่ (ปัจจุบัน! = null) {current.displaylink (); current = current.next; }} โมฆะสาธารณะ displayListreverse () {// ลิงค์ข้ามผกผัน <t> p = head, q = head.next, t; ในขณะที่ (q! = null) {// ตัวชี้กลับด้านและลำดับข้อมูลที่ผ่านการสำรวจจะย้อนกลับ t = q.next; // no3 ถ้า (p == หัว) {// เมื่อเป็นส่วนหัวดั้งเดิม,. next ของหัวควรว่าง p.next = null; } q.next = p; // no3 -> no1 ตัวชี้ย้อนกลับ p = q; // start คือ reverse q = t; // no3 start} // ใน IF ในลูปด้านบน head.next ว่างเปล่าเมื่อ Q เป็น null และไม่ดำเนินการลูป p เป็นรายการข้อมูลส่วนใหญ่ดั้งเดิม หลังจากการผกผัน p ถูกกำหนดให้หัวหัว = p; DisplayList (); } class link <t> {// link point t data; // ลิงค์โดเมนข้อมูล <t> ถัดไป; // ตัวชี้ต่อเนื่องลิงก์โดเมนโซ่โหนด (ข้อมูล t) {this.data = data; } void displayLink () {system.out.println ("ข้อมูลคือ" + data.toString ()); }} โมฆะคงที่สาธารณะหลัก (String [] args) {singlelinkedList2 <integer> list = singlelinkedList2 <integer> (); list.insertlast (33); list.insertlast (78); list.insertlast (24); list.insertlast (22); list.insertlast (56); list.displaylist (); list.deletelast (); list.displaylist (); System.out.println ("ค้นหา:" + list.find (56)); System.out.println ("ค้นหา:" + list.find (33)); System.out.println ("ลบค้นหา:" + list.delete (99)); System.out.println ("ลบค้นหา:" + list.delete (78)); list.displaylist (); System.out.println ("---- ย้อนกลับ -----"); list.displaylistreverse (); -พิมพ์
รายการ (head-> สุดท้าย): ข้อมูลคือ 33 ข้อมูลคือ 78 ข้อมูลคือ 24 ข้อมูลคือ 22 ข้อมูลคือ 56 รายการ (หัว-> สุดท้าย): ข้อมูลคือ 33 ข้อมูลคือ 78 ข้อมูลคือ 24 ข้อมูลคือ 22 ค้นหา ค้นหา: linked_list.singlelinkedlist2$link@17dfafd1 รายการ (หัว-> สุดท้าย): ข้อมูลคือ 33 ข้อมูลคือ 24 ข้อมูลคือ 22 --- ย้อนกลับ --- รายการ (หัว-> สุดท้าย): ข้อมูลคือ 22 ข้อมูลคือ 24 ข้อมูลคือ 33 ข้อมูลคือ 33
จำลองรายการที่เชื่อมโยงสองครั้งเพื่อใช้สแต็กและคิวด้วยรายการที่เชื่อมโยง
รายการเชื่อมโยงสองเท่า:
รายการที่เชื่อมโยงสองปลายนั้นคล้ายกับรายการที่เชื่อมโยงแบบดั้งเดิมมาก มีการเพิ่มแอตทริบิวต์ใหม่เท่านั้น - นั่นคือการอ้างอิงถึงลิงค์สุดท้ายคือด้านหลัง
ด้วยวิธีนี้การแทรกที่ปลายโซ่จะกลายเป็นเรื่องง่ายมาก เพียงแค่เปลี่ยนด้านหลังของด้านหลังเป็นโหนดที่เพิ่มขึ้นใหม่โดยไม่ต้องวนรอบเพื่อค้นหาโหนดสุดท้ายดังนั้นจึงมี insertfirst และ insertlast
เมื่อลบส่วนหัวของโซ่คุณจะต้องเปลี่ยนจุดอ้างอิงเท่านั้น เมื่อลบหางโซ่คุณจะต้องล้างโหนดถัดไปของโหนดสุดท้าย
ไม่มีจุดอ้างอิงถึงมันดังนั้นจำเป็นต้องมีลูปเพื่ออ่านการดำเนินการ
/ *** รายการที่เชื่อมโยงสองเท่า* @author Stone*/ คลาสสาธารณะ TwoendPointList <T> {LINK ส่วนตัว <T> Head; // First Node Private Link <T> ด้านหลัง; // ตัวชี้หางสาธารณะ twoendPointList () {} สาธารณะ t peekhead () {if (head! = null) {return head.data; } return null; } บูลีนสาธารณะ isempty () {return head == null; } โมฆะสาธารณะ INSERTFIRST (ข้อมูล t) {// แทรกไปที่หัวของลิงค์โซ่ <T> newLink = ลิงก์ใหม่ <T> (ข้อมูล); newLink.next = head; // ถัดไปของโหนดใหม่ชี้ไปที่หัวโหนดก่อนหน้า = newLink; } โมฆะสาธารณะ InsertLast (t data) {// แทรกลิงค์ <t> newLink = ลิงก์ใหม่ <t> (ข้อมูล); if (head == null) {rear = null; } if (ด้านหลัง! = null) {rear.next = newLink; } else {head = newLink; head.next = ด้านหลัง; } rear = newLink; // ในครั้งต่อไปที่คุณแทรกแทรกจากด้านหลัง} สาธารณะ t deletehead () {// ลบส่วนหัวโซ่ถ้า (isempty ()) ส่งคืน null; ลิงค์ <t> อุณหภูมิ = หัว; head = head.next; // เปลี่ยนโหนดแรกเป็นโหนดถัดไปถ้า (head == null) {<span style = "space สีขาว: pre"> </span> hear = head; } return temp.data; } สาธารณะ t ค้นหา (t t) {ถ้า (isempty ()) {return null; } link <t> find = head; ในขณะที่ (ค้นหา! = null) {ถ้า (! find.data.equals (t)) {find = find.next; } else {break; }} if (find == null) {return null; } return find.data; } สาธารณะ t ลบ (t t) {ถ้า (isempty ()) {return null; } else {ถ้า (head.data.equals (t)) {link <t> temp = head; head = head.next; // เปลี่ยนโหนดแรกเป็นโหนดส่งคืน temp.data; }} ลิงก์ <t> p = head; ลิงก์ <t> q = head; ในขณะที่ (! p.data.equals (t)) {if (p.next == null) {// ระบุว่าไม่พบ null return ที่ปลายโซ่; } else {q = p; p = p.next; }} q.next = p.next; กลับ p.data; } โมฆะสาธารณะ displayList () {// travel system.out.println ("รายการ (หัว-> สุดท้าย):"); ลิงก์ <t> current = head; ในขณะที่ (ปัจจุบัน! = null) {current.displaylink (); current = current.next; }} โมฆะสาธารณะ displayListreverse () {// ผกผัน traversal ถ้า (isempty ()) {return; } link <t> p = head, q = head.next, t; ในขณะที่ (q! = null) {// ตัวชี้กลับด้านและลำดับข้อมูลที่ผ่านการสำรวจจะย้อนกลับ t = q.next; // no3 ถ้า (p == หัว) {// เมื่อเป็นหัวดั้งเดิม,. next ของหัวควรว่าง p.next = null; } q.next = p; // no3 -> no1 ตัวชี้ย้อนกลับ p = q; // start คือ reverse q = t; // no3 start} // ใน if ในลูปด้านบน head.next ว่างเปล่าและเมื่อ q เป็น null และไม่ดำเนินการลูป p คือรายการข้อมูลส่วนใหญ่ดั้งเดิม หลังจากการผกผัน p ถูกกำหนดให้หัวหัว = p; DisplayList (); } class link <t> {// link node t data; // ลิงค์โดเมนข้อมูล <t> ถัดไป; // ตัวชี้ต่อเนื่องลิงก์โดเมนโซ่โหนด (ข้อมูล t) {this.data = data; } void displayLink () {system.out.println ("ข้อมูลคือ" + data.toString ()); }} โมฆะคงที่สาธารณะหลัก (String [] args) {twoendPointList <integer> list = new TwoendPointList <integer> (); list.insertlast (1); list.insertfirst (2); list.insertlast (3); list.insertfirst (4); list.insertlast (5); list.displaylist (); list.deletehead (); list.displaylist (); System.out.println ("ค้นหา:" + list.find (6)); System.out.println ("ค้นหา:" + list.find (3)); System.out.println ("ลบค้นหา:" + list.delete (6)); System.out.println ("ลบค้นหา:" + list.delete (5)); list.displaylist (); System.out.println ("--- ย้อนกลับ ----"); list.displaylistreverse (); -พิมพ์
รายการ (head-> สุดท้าย): ข้อมูลคือ 4 ข้อมูลคือ 2 ข้อมูลคือ 1 ข้อมูลคือ 3 ข้อมูลคือ 5 รายการ (หัว-> สุดท้าย): ข้อมูลคือ 2 ข้อมูลคือ 1 ข้อมูลคือ 3 ข้อมูลคือ 5 ค้นหา: null find: 3 delete find: null delete find: 5 รายการ
ใช้รายการที่เชื่อมโยงเพื่อใช้สแต็กและใช้รายการที่เชื่อมโยงเดียวก่อนที่จะแทรก
คลาสนี้ใช้รายการที่เชื่อมโยงสองครั้งเพื่อนำไปใช้:
LinkStack คลาสสาธารณะ <T> {ส่วนตัว TwoendPointList <T> DATA; Public LinkStack () {datas = ใหม่ TwoendPointList <T> (); } // ใส่ลงในโมฆะสาธารณะสแต็ก (ข้อมูล t) {dataS.insertFirst (ข้อมูล); } // วางสแต็กสาธารณะ t pop () {return data.deletehead (); } // ตรวจสอบด้านบนของสแต็กสาธารณะ t peek () {return data.peekhead (); } // ว่าสแต็กเป็นบูลีนสาธารณะที่ว่างเปล่า isempty () {return dataS.isempty (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {linkstack <integer> stack = new LinkStack <Integer> (); สำหรับ (int i = 0; i <5; i ++) {stack.push (i); } สำหรับ (int i = 0; i <5; i ++) {integer peek = stack.peek (); System.out.println ("peek:" + peek); } สำหรับ (int i = 0; i <6; i ++) {จำนวนเต็มป๊อป = stack.pop (); System.out.println ("ป๊อป:" + ป๊อป); } system.out.println ("----"); สำหรับ (int i = 5; i> 0; i--) {stack.push (i); } สำหรับ (int i = 5; i> 0; i--) {integer peek = stack.peek (); System.out.println ("peek:" + peek); } สำหรับ (int i = 5; i> 0; i--) {จำนวนเต็มป๊อป = stack.pop (); System.out.println ("ป๊อป:" + ป๊อป); -พิมพ์
Peek: 4 peek: 4 peek: 4 peek: 4 peek: 4 peek: 4 ป๊อป: 4 ป๊อป: 3 ป๊อป: 2 ป๊อป: 1 ป๊อป: 1 ป๊อป: 0 ป๊อป: null --- peek: 1 peek: 1 peek: 1 peek: 1 ป๊อป: 1 ป๊อป: 1 ป๊อป: 2 ป๊อป: 3 ป๊อป: 4 ป๊อป: 5 ป๊อป: 5 ป๊อป: 5 ป๊อป: 5 ป๊อป: 5
คิวการใช้งานรายการที่เชื่อมโยงถูกนำมาใช้โดยใช้รายการที่เชื่อมโยงสองเท่า:
Linkqueue ชั้นเรียนสาธารณะ <T> {Private TwoendPointList <T> รายการ; Public LinkQueue () {list = new TwoendPointList <T> (); } // แทรกหางของช่องว่างสาธารณะคิว (ข้อมูล t) {list.insertLast (ข้อมูล); } // ลบหัวของทีมสาธารณะ t ลบ () {return list.deletehead (); } // ดูหัวหน้าทีมสาธารณะ t peek () {return list.peekhead (); } บูลีนสาธารณะ isempty () {return list.isempty (); } โมฆะคงที่สาธารณะหลัก (สตริง [] args) {linkqueue <จำนวนเต็ม> queue = ใหม่ linkqueue <integer> (); สำหรับ (int i = 1; i <5; i ++) {queue.insert (i); } สำหรับ (int i = 1; i <5; i ++) {integer peek = queue.peek (); System.out.println ("peek:" + peek); } สำหรับ (int i = 1; i <5; i ++) {จำนวนเต็มลบ = queue.remove (); System.out.println ("ลบ:" + ลบ); } system.out.println ("----"); สำหรับ (int i = 5; i> 0; i--) {queue.insert (i); } สำหรับ (int i = 5; i> 0; i--) {integer peek = queue.peek (); System.out.println ("peek2:" + peek); } สำหรับ (int i = 5; i> 0; i--) {จำนวนเต็มลบ = queue.remove (); System.out.println ("ลบ:" + ลบ); -พิมพ์
peek: 1 peek: 1 peek: 1 peek: 1 peek: 1 ลบ: 1 ลบ: 2 ลบ: 3 ลบ: 4 --- peek2: 5 peek2: 5 peek2: 5 peek2: 5 peek2: 5 ลบ: 5 ลบ: 4 ลบ: 3 ลบ: 2 ลบ: 1