verkettete Listen

[Nummer6800]

Hier handelt es sich um eine einfach verkettete Liste. Wo man verschiedene Methoden ausfuehren kann.


l.insert(new Node(1)); Methode insert aus Class List wird benutzt. Node n wird erwartet Parameter eins wird uebergeben.

Aber Klasse Node hat zwei Konstruktoren. Dann wird der Erste genommen. Wegen dem Node n. Aber woher wird dann das next = n im Konstruktor geliefert?

Aus den Variablen ganz oben in Klasse Node? Jedenfalls wird doch bei l.insert(new Node(1)); nur das element = 1 uebergeben?

// l.insert(new Node(1)); Methode insert aus Class List wird benutzt. Node n wird erwartet
// Parameter eins wird uebergeben.
// Aber Klasse Node hat zwei Konstruktoren. Dann wird der Erste genommen. Wegen dem Node n. Aber woher wird dann das next = n im Konstruktor geliefert?
// Aus den Variablen ganz oben in Klasse Node? Jedenfalls wird doch bei l.insert(new Node(1)); nur das element = 1 uebergeben?



public class TestList {

    public static void main(String args[]) {

        List l;

        
// neue Liste

        l = new List();

// alloziere Knoten
// ! Hier ist der Punkt den ich nicht verstehe

        l.insert(new Node(1));

        l.insert(new Node(4));

        l.insert(new Node(5));

        l.insert(new Node(2));

        

        l.dump();

        

        l.delete(5);

        

        l.dump();

    }

}




public class Node {

    public int   element = 0;

    public Node  next    = null;

    
// Konstruktor 1

    public Node(int e, Node n) {

        element = e;

        next    = n;

    }

// Konstruktor 2

    public Node(int e) {

        element = e;

    }

}





public class List {

    public Node head;

    

// am Kopf einfuegen Methode insert

    public void insert(Node n) {

        n.next = head;

        head   = n;

    }

    

    public void delete(int key) {

        Node current = head;

        

        if (head.element == key) {

            head = head.next;

            return ;

        }

        

        while (current.next!=null) {

            if (current.next.element==key)

                current.next = current.next.next;

            current = current.next;

        }

    }

    

    public Node search(int key) {

        Node current = head;

        

        while (current!=null) {

            if (current.element==key)

                return current;

            current = current.next;

        }

        return current;

    }



    public void dump() {

        Node current = head;

        

        System.out.println("dumping list");

        while (current!=null) {

            System.out.println("   element: "+current.element);

            current = current.next;

        }

    }

    

}

 

[Joose]

Aber woher wird dann das next = n im Konstruktor geliefert?

Aus den Variablen ganz oben in Klasse Node? Jedenfalls wird doch bei l.insert(new Node(1)); nur das element = 1 uebergeben?

Die Klasse Node bietet dir 2 verschiedene Konstruktoren an.
Warum sollte er Konstruktor 1 verwenden?
Wie müsste der Aufruf für Konstruktor 1 bzw. 2 ausschauen?

 

[Nummer6800]

Danke Fuer die Antwort.

Aber dann benutzt er Konstruktor 2. Da wird nur int angeboten.

Aber Methode insert verlangt doch vom Typ Node n.

Und ausserdem brauche ich doch einen Konstruktor der mir "next" liefert.
Sonst funktioniert doch insert Methode nicht.

Konstruktor 1
wird mit Typ vom Node gerufen
und ein element von int

Konstruktor 2
da reicht ein Element vom Typ int

P.S.
Es ist keine Hausaufgabe. Also gelten keine Forenregeln fuer Hausaufgaben.

 

[Tarrew]

Der 2. Konstruktur wird also mit:

l.insert(new Node(1));

aufgerufen, da nur ein int übergeben wird.

Und ein "Node" sieht ja so aus:

public class Node {
 
    public int   element = 0;
 
    public Node  next    = null;
}

Wenn jetzt der 2. Konstruktor aufgerufen wird, dann wird das int element geändert.
Nur weil das "next" im Konstuktor nicht genutzt wird, heißt das nicht, dass es nicht existiert. Es ist immer noch ein Attribut des Objekts. Es bleibt eben nur erstmal null.

public void insert(Node n) {
 
        n.next = head;
 
        head   = n;
 
    }

Das next wird ja dann in der insert-Methode geändert. Vorher war es nur null.

Der 1. Konstuktur kann zB nützlich sein, wenn du Knoten in der Mitte deiner Liste einfügen willst und nicht am head.

 

[Nummer6800]

Danke. Hatte das mit der Variable next in der Klasse nicht bedacht.
War zu sehr auf die Konstruktoren fixiert.