// Klasse zum Testen der einfach verketteten Liste
// s. Node.java
public class NodeTest {

	public static void main(String[] args) {
		// Erstes Element
		Node start = new Node();
		start.data = "Hallo, Welt!"; // Nutzdaten (irrelevant)
		start.next = null; // Kein weiteres Element da.
		
		start.next = new Node();
		start.next.data = "Fortsetzung";
		start.next.next = null;
		
		start.next.next = new Node();
		start.next.next.data = "...folgt.";
		start.next.next.next = null;
		
		// Das ist viel zu aufwändig (.next.next....)
		// Noch mal besser mit einem "wandernden Zeiger"
		start = new Node();
		Node aktuell = start;
		aktuell.data = "Node Nr. " + 0;
		
		// 999 weitere anfügen
		for(int i=1; i<=999; i++) {
			aktuell.next = new Node();
			aktuell.next.data = "Node Nr. " + i;
			aktuell = aktuell.next; // Zeigt nun auf die neue Node!
		}
		aktuell.next = null;
		
		// An dieser Stelle angekommen haben wir nun eine Liste
		// mit 1000 Node-Elementen, die durch den "next"-Zeiger
		// verkettet sind.
		
		// Wir gehen vom Anfang 100 Elemente weiter in der Liste
		aktuell = start;
		for(int i=1; i<=100; i++) {
			// Falls kein weiteres Element existiert -> Abbruch
			if(aktuell.next == null) break; 
			aktuell = aktuell.next;	 // Ansonsten 1 weiter.
		}
		// Mal schauen, was dort im Datenfeld steht:
	    System.out.println("Im Element Nr 100 (101. Element) steht: "
	    		+ aktuell.data);
	    
	    // Bei Arrays wäre eine Suche:
	    // for(int i=0; i< array.length; i++)
	    //  if(array[i].data.equals("100")
	    //    System.out.println("Gefunden an Stelle " + i);

	    // Bei verketteten Listen so:
	    aktuell = start;
	    int count = 0;
	    while(aktuell != null) { // So lange Ende nicht erreicht
	    	if(((String)aktuell.data).equals("Node Nr. 100")) {
	    		System.out.println("Gefunden im Objekt " + aktuell
	    				+ " im " + count + ". Element");
	    		break;
	    	}
	    	aktuell = aktuell.next;
	    	count++;
	    }
	    
	    // Nun soll ein neues Element in die Liste eingebaut werden,
	    // uns zwar als (neuer) Nachfolger von start;
	    
	    Node neu = new Node();
	    neu.data = "Neu";

	    // ZUERST in das neue Element dessen Nachfolger eintragen...
	    neu.next = start.next;
	    // DANN das neue Element als Nachfolger des ersten eintragen.
	    start.next = neu;
	    
	    // Nun soll das neue Element wieder aus der Liste entfernt
	    // werden (ohne dass wir den "neu" Zeiger weiter verwenden)
	    
	    start.next = start.next.next; // Nachfolger "überspringen"
	    
	    // Achtung: Wenn hinter Start KEIN Nachfolger kommt
	    // (start.next wäre null) dann lässt sich
	    // natürlich auch kein Nachfolger löschen, also ist die
	    // sicherere Variante
	    // if(start.next != null) start.next = start.next.next;
	    
	    // Merksatz: Folge nie einem NULL Zeiger!
	    
	    // Normalerweise würden wir ei der OOP die Funktionen zum
	    // Einfügen oder Entfernen direkt in die Node-Klasse einbauen.
	    // so dass in main() einfach aktuell.insert(new Node());
	    // aufgerufen werden kann etc.
	    
	    
	    
	    
	    
	    
	    
	}

}