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.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!
