Einführung und Verwendung einfach verknüpfter Listen in Java

Einfach verknüpfte Liste:
* 1. Die verknüpfte Liste kann eine geordnete oder ungeordnete Liste sein
* 2. Der Inhalt der verknüpften Liste wird normalerweise im Speicher gespeichert, bis er verteilt wird
* 3. Die verknüpfte Liste besteht aus Knoten. Jeder Knoten hat die gleiche Struktur
* 4. Knoten sind in Datendomäne und Kettendomäne unterteilt. Die Datendomäne speichert den Knoteninhalt und die Kettendomäne speichert den Zeiger des nächsten Knotens

Paket myLinkList;

public class MyLinkedList ){

 }
 //Knoteninitialisierung
 public Node(T data,Node next){
  this.data = data; }
}

privater Knoten-Header;//Kopfknoten der verknüpften Liste
privater Knoten-Tailer;//Endknoten der verknüpften Liste
private int size;//Länge der verknüpften Liste (Anzahl der Knoten)


/**
*Knoten: Knotenobjekt
* Enthält Datenfelddaten und Linkfeld weiter (zeigt auf das nächste Knotenobjekt)
*/
public MyLinkedList() {//Leere Parameterkonstruktion
header = null;
tailer = null;
}
public MyLinkedList(T data ) {//Konstruktion mit Parametern
　header = new Node(data,null);//Header-Knoten erstellen
　tailer = header;
　size++;
}

/**
* Initialisierung der verknüpften Liste
*/
public int getSize() {
　return size;
}

/**
* Finden Sie die Länge der verknüpften Liste
* @return
*/
public T get( int index) {
　if(index < 0 || index > size-1)
　　throw new IndexOutOfBoundsException("index out ofbounds");
　　return getIndexNode(index).data;
}

public Node getIndexNode(int index){
　if(index < 0 || index > size-1)
　　throw new IndexOutOfBoundsException("index out ofbounds");
　Node current = header;
　for(int i = 0;i < size; i++) {
　　if(i == index) {
　　return current;
　　}
　　current = current.next ;
}
return null;
}

/**
* Gibt die Daten des Knotens mit Indexindex zurück
* @param index index
* @return
*/
public int getIndex(T element) {
if(element == null)
　　return -1;
　Node current = header;
　for(int i = 0; i < size; i++) {
　　if(current.data == element){
　　return i ;
}
current = current.next;
}
return -1;
}



/**
* Gibt die Position des Elements in der verknüpften Liste zurück. Wenn es nicht existiert, wird -1 zurückgegeben
* @param tdata
* @return
*/
public void add(T element) {
　Node n = new Node(element,null);
　if(header == null){
　header = n;
　tailer = header;
}else{
tailer.next = n;
tailer = n;
}
size++;
}

/**
* Element hinzufügen
am Ende der verknüpften Liste * @param-Element
*/
public void addAtheader(T element) {
header = new Node(element,header);
if(tailer == null){
tailer = header;
}
size++; 🎜> }

/**
* Element hinzufügen
am Kopf der verknüpften Liste * @param-Element
*/
public void insert(int index,T element) {
　if(index<0 || index>size-1) {
throw new IndexOutOfBoundsException("index out ofbounds");
}
if(header==null){
add(element); ){
　　addAtheader(element);
　} else{
　　　Node current = getIndexNode(index);
　　　　Node insertNode = new Node(element,current.next);
　　　current.next = insertNode;
　　　size++;
　　}
}
}
/**
* Element nach Indexposition einfügen
* @param index
* @param element
*/
public T deleteNode(int index){
　if(index<0 | | index>size-1)
　　 throw new IndexOutOfBoundsException( "Index außerhalb der Grenzen"); Node
　　header = header.next;//Zeigen Sie den Kopfzeiger auf den nächsten Knoten
　　size--;
　　return n.data;//Gib den Inhalt des aus Knoten aufzeichnen
　　}else{//In Andere Positionen löschen
　　Node current = getIndexNode(index);//Den aktuellen Knoten abrufen
　　Node pre = getIndexNode(index-1);//Den vorherigen Knoten abrufen
　　pre.next = current.next;/ /Setze das Kettenfeld des vorherigen Knotens auf null
　　size--;
　　return current.data;//Gib das Datenfeld des gelöschten Knotens zurück
　　}


}
/**
* Knoten an beliebiger Position löschen
* @param index
* @return
*/
public T deleteHeader(){
　　return deleteNode(0);
}
/* *
* Löschen Sie den Hauptknoten
* @return
*/
public T deleteTailer() {
return deleteNode(size-1);
}

//Knoten löschen
public void clear(){
　　header = null;
　　tailer = null;
　　size = 0;
}

/**
* toString();
*/
public String toString(){
　　if(size == 0)
　　　　return "[]";
　　Node current = header;
　　StringBuilder sb = new StringBuilder();
　　sb.append(" [") > 　　sb.append(current.data).append("]");
　　return sb.toString();
}


public static void main(String[] args) {
　　MyLinkedList link = new MyLinkedList<>();
　　link.add("header");
　　link.add("11");
　　link.add("22");
　　link .add("33");
　　link.addAtheader("newheader");
　　link.insert(2, "1.5");;

　　System.out.println(link.getIndex ("11"));
　　System.out.println(link.getIndex("88"));
　　System.out.println(link.get(0));
　　System.out. println(link.getSize());
　　System.out.println(link.deleteHeader());
　　System.out.println(link.deleteTailer());
　　System.out.println( link.deleteNode(1));
　　System.out.println(link);
　　link.clear();
　　System.out.println(link);

　　}

}

Das obige ist der detaillierte Inhalt vonEinführung und Verwendung einfach verknüpfter Listen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!