1. Übersicht
Eine einfach verknüpfte Liste (einzelne verknüpfte Liste) ist eine Art verknüpfter Liste, die dadurch gekennzeichnet ist, dass die Verknüpfungsrichtung der verknüpften Liste unidirektional ist und der Zugriff auf die verknüpfte Liste vom Kopf aus durch sequentielles Lesen beginnt; die Verknüpfung Liste ist eine Liste, die mithilfe von Zeigern erstellt wurde . Auch als Knotenliste bekannt, da die verknüpfte Liste aus Knoten zusammengesetzt ist. Jeder Knoten verfügt über eine Zeiger-Mitgliedsvariable, die auf den nächsten Knoten in der Liste zeigt.
Die verknüpfte Liste besteht aus Knoten und Der Kopfzeiger zeigt auf Der erste wird zum Kopfknoten und der letzte endet mit einem Zeiger auf NULL.
Eine doppelt Jeder ihrer Datenknoten verfügt über zwei Zeiger, die auf den direkten Nachfolger bzw. den direkten Vorgänger zeigen . Daher können Sie ausgehend von jedem Knoten in der doppelt verknüpften Liste problemlos auf dessen Vorgängerknoten und Nachfolgerknoten zugreifen. Im Allgemeinen erstellen wir eine bidirektionale zirkulär verknüpfte Liste.
//1. Verknüpfte Liste mit einem Element
@Test
public void node() { //Verknüpfte Liste aufteilen: Node headNode = new Node(0); Node current = headNode; int[] a = {1, 2, 3, 4 , 5}; for (int i = 0; i < 5; i++) { Node temp = new Node(a[i]); current.setNext(temp);//Der aktuelle Knoten zeigt auf 2, um einen neuen hinzuzufügen node (next)3 current = temp; //Ändern Sie die Adresse dieses Knotens von 2 auf 3 } //Einzelne verknüpfte Liste Doppelte verknüpfte Liste //1. So kehren Sie die einfach verknüpfte Liste und die doppelt verknüpfte Liste um / /2. Löschen Sie den angegebenen Wert Node pre=null; Node next =null; while(headNode!=null){ next=headNode.getNext(); //Der erste Punkt headNode.setNext(pre); //pre Der zweite node setzt den ersten Knoten pre=headNode; // Flashback-Kopfknoten abrufen und in pre speichern headNode=next; //Anfänglicher Kopfknoten } System.out.println(pre.toString());
}
//Einzelne verknüpfte Liste entfernt einen bestimmten Wert
public Node removeNode(Node head, int num) {
while (head != null) {
if (head.value != num) {
break;
}
head = head.next;
}
Node pre = head;
Node cur = head;
while (cur != null) {
if (cur.value == num) {
pre.next = cur.next;
} else {
pre = cur;
}
cur = cur.next;
}
return head;
}
//2. Die doppelt verknüpfte Liste wurde gelöscht und geändert
/**
-
Doppelt verknüpfte Listenknotenklasse
/
öffentliche Klasse DoubleNode { int value; String name; DoubleNode next; DoubleNode pre; } /
* -
Doppelt verknüpfte Liste-verknüpfte Listenklasse
*/
öffentliche Klasse DoubleLinkedClass { // tatsächliche Anzahl der Speicherelemente int size; // Kopfknoten der doppelt verknüpften Liste privater DoubleNode zuerst; // Endknoten der doppelt verknüpften Liste privater DoubleNode zuletzt;//Kopfinterpolationsmethode
public void addFirst(int val){ // Den Kopfknoten vorübergehend speichern DoubleNode head = first; // 1. Zuerst einen neuen Knoten erstellen DoubleNode node = new DoubleNode(val); // 2. Dann zeigen Kopfknoten zum neu eingefügten Knoten first = node; // Achten Sie auf null if (head == null) { // Wenn die verknüpfte Liste leer ist, ist der Endknoten der Kopfknoten last = node; } else { // 3 . Kombinieren Sie den Nachfolger des neuen Knotens mit Das ursprüngliche erste Element wird verbunden, und dann wird der Vorgänger des ursprünglichen ersten Knotens mit dem neuen Knoten verbunden node.next = head; head.pre = node; } size++; System.out. println("dfksjfi"); System.out .println(head.toString()); }
// Tail-Interpolationsmethode
public void addLast(int val) { DoubleNode l = last; DoubleNode node = new DoubleNode(val); last = node; // Achten Sie auf leer if (l == null) { // Der Kopfknoten ist der Endknoten first = node; } else { node.pre = l; l.next = node; } size++; System.out.println(“dfksjfi”); } //Initialisiere den Kopfknoten private DoubleNode head = new DoubleNode (0 ); //Kopfknoten zurückgeben public DoubleNode getHead(){ return head; } /**
- Die hinzugefügten Knoten der doppelt verknüpften Listenknoten sind unabhängig voneinander und die Aufwärts- und Abwärtszeiger werden zum Verknüpfen der Beziehung verwendet
- @param heroNode
*/
public void add(DoubleNode heroNode){ DoubleNode temp = head; while(true){ if(temp.next == null){ break; } temp = temp.next; } //Bilden Sie eine doppelt verknüpfte Liste temp. next = heroNode; heroNode. pre = temp; }
public void addByOrder(DoubleNode heroNode){ DoubleNode temp = head; boolesches Flag = false; while(true){ if(temp.next == null){ break; } if(temp.next.value == heroNode.value){ flag = true; brechen; } if(temp.next.value > heroNode.value){ break; } temp = temp.next; }
if(flag){ System.out.println("要添加的节点编号已经存在"); }else{ if (temp.next != null) { temp.next.pre = heroNode; //heroNode和后一个节点建立链接 heroNode.next = temp.next; } temp.next = heroNode; //heroNode和前一个节点建立链接 heroNode.pre = temp; }}
/**
- Änderung doppelt verknüpfter Listenknoten
- @param newHeroNode
*/
public void update(DoubleNode newHeroNode){ if(head.next == null){ System.out.println("Die verknüpfte Liste ist leer"); return; } DoubleNode temp = head.next; boolesches Flag = false ; while(true){ if(temp == null){ break; } if(temp.value == newHeroNode.value){ flag = true; // break; } if(flag){ temp.name = newHeroNode .name ; flag = false; // temp.nickname = newHeroNode.nickname; }else { System.out.println("Kein Knoten mit Nummer " + newHeroNode.value + " gefunden"); } temp = temp.next; }
}
/**
-
Knoten in einer doppelt verknüpften Liste löschen
-
@param no
*/
public void delete(int no){// Der Unterschied besteht darin, dass es sich von der einfach verknüpften Liste unterscheidet. Sie können direkt vom ersten Knoten nach dem Kopf aus suchen und der Hilfszeiger zeigt direkt auf den ersten gültigen Knoten
if(head.next == null){ System.out.println("verknüpfte Liste ist leer"); return; } DoubleNode temp = head.next; boolean flag = false; while(true){ if(temp.next == null){ break; } if(temp .next.value == no){ flag = true; break; } temp = temp.next; } if(flag){ // // zu löschende Knotenposition finden // temp.pre.next = temp.next ; // // Hinweis: Wenn es sich um den letzten One-Knoten handelt, muss der folgende Absatz nicht ausgeführt werden // if(temp.next != null) { // temp.next.pre = temp.pre; // } //Der letzte Knoten wird entfernt if(temp. next.next==null){
temp.next.pre=null;
temp.next=null;
}
//Wenn es nicht der letzte Knoten ist
if(temp.next.next!=null){ temp.next.next.pre=temp.next.pre; temp. next= temp.next.next; } }else { System.out.println("Die zu löschende Nummer ist" + no + "Knoten existiert nicht"); } }
/**
-
Durchquerung doppelt verknüpfter Listenknoten
*/
public void list(){ if(head.next == null){ System.out.println("Die verknüpfte Liste ist leer"); return; }
DoubleNode temp = head.next;
while(true){ if(temp == null){ break; } //Knoteninformationen ausgeben System.out.println(temp); temp = temp.next; } }
@Test
public void testNode(){ DoubleNode node = new DoubleNode(6); DoubleNode node1 = new DoubleNode(2); DoubleNode node2 = new DoubleNode(3); DoubleNode node3 = new DoubleNode(2); //Erweiterte DoubleLinkedClass-Klasse linkedClass=new DoubleLinkedClass(); linkedClass.add(node); linkedClass.add(node1); linkedClass.add(node2); linkedClass.addByOrder(node3);
// first=node;
// int val=4;
// addFirst(val);
// addLast(5);
System.out.println(“sdkfjshdkfh”);
linkedClass.list();
// System.out.println("------------------------ --- -------------");
// //
DoubleNode ändern newHeroNode = new DoubleNode(2,"nike");
LinkedIndClass.update(newHeroNode);
LinkedIndClass.list();
System.out .println("---------------------------- --- -----------");
//
// //delete
LinkedIndClass.delete(2);
LinkedClass.list();
System.out.println("------ --- ----------------------------------------------- -") ;
//
// // In der Reihenfolge hinzufügen
// HeroNode2 newHeroNode2 = new HeroNode2(6,"Keko","Little Horse");
// HeroNode2 newHeroNode3 = new HeroNode2(5,"Feifei","Xiaoma" Sheep") ;
// LinkedInedClass.addByOrder(newHeroNode2);
// LinkedInedClass.addByOrder(newHeroNode3);
// linkedClass.list();
System.out.println(“---------------------------- --------------“);
}
}