# LinkedList



## rogue (4. Mai 2011)

Hallo, 

ich bin neu hier und hab leider das Problem eine Aufgabe ganz nicht zu verstehen.

Könnte mir jemand helfen und mir erklären wie ich die einzelnen Werte in der Liste 
der folgenden Aufgabe ansteuern kann. Das habe ich immer noch nicht verstanden. 

Wir sollen folgenden Quellcode um diese Funktionen erweitern:

E remove(int index)  (Entfernt das Element an der spezifizierten Position in der Liste),

boolean remove(Object o) (Entfernt das erste Auftauchen des spezifizierten Elements aus der Liste, falls es vorhanden ist),

und int indexOf(Object o) ( Gibt den Index für das erste Auftauchen  des gesuchten Elements in der Liste, odoer gibt -1 zurück wenn es nicht vorhanden ist.


```
import java.lang.Iterable;
import java.util.Iterator;

public class LinkedList<E> implements List<E> {
    
	private class Wrapper {
		E e;
		Wrapper succ;
		
		Wrapper(E e){
			this.e = e;
			succ = null;
		}
	}
	
	Wrapper first;
	Wrapper last;
	int size;
	
	LinkedList(){
		first = null;
		last = null;
		size = 0;
	}

	public boolean add(E e) {
		Wrapper w = new Wrapper(e);
		if (size == 0){
			first = w;
			last = w;
		} else {
			last.succ = w;
			last = w;
		}
		size++;
		return true;
	}

	public E get(int index) {
		Wrapper wRun;
		if (index < 0 || index >= size){
			throw new IndexOutOfBoundsException();
		}
		wRun = this.first;
		for (int iRun = 0; iRun < index; iRun++){
			wRun = wRun.succ;
		}
		return wRun.e;
	}

	public int size() {
		return size;
	}

	public Iterator<E> iterator() {
		return new Iterator<E>(){
			Wrapper next = first;
			Wrapper current;

			public boolean hasNext() {
				return next != null;
			}

			public E next() {
				current = next;
				if (next != null){
					next = next.succ;
				}
				return current.e;
			}

			public void remove() {
				throw new UnsupportedOperationException();	
			}
		};

	}

        public E remove(int index){
            

        public boolean remove(Object o){

            
        }

        public int indexof(Object o){

            

        }

}
```


----------



## Final_Striker (4. Mai 2011)

Was genau verstehst du denn nicht?
Du hast doch schon 3 Beispielmethoden (add, get, iterator) in denen die Listenelemente (Wrapper) benutzt werden.


----------



## rogue (4. Mai 2011)

Hallo, danke für deine Antwort.

Es will einfach irgendwie nicht in meinen Kopf wie ich schon vorhandene Elemente lösche oder ändere und die Liste dann kürze.

Es ist bestimmt ganz einfach aber ich hab irgendwie einen Denkfehler.


----------



## Final_Striker (4. Mai 2011)

ListenElement->Next(succ)

Liste:
A->B, B->C, C->Null

Wir wollen B löschen. Was machen wir? Wir lassen den Next-Zeiger des Vorgängers von B (also A) auf den Nachfolger von B (also C) zeigen.

A->C, C->Null

Somit ist jetzt das Element B aus der Liste gelöscht.


----------



## rogue (4. Mai 2011)

Das Grundprinzip habe ich jetzt verstanden. Aber wie spreche ich genau die beiden Zeiger an. Ich denk immer noch zu sehr an Arrays.


----------



## Final_Striker (4. Mai 2011)

rogue hat gesagt.:


> Aber wie spreche ich genau die beiden Zeiger an.



So wie es z.B in der deiner add-Methode gemacht wird.


----------



## rogue (4. Mai 2011)

Hallo,

ich habe es jetzt geschafft, mit ein bisschen rumprobieren, die Methode remove zu schreiben.

Vielen Dank für die Hilfe.

Ich wollte noch fragen ob man es noch ein bisschen vereinfachen könnte. Ich hab die Angewohnheit alles etwas zu kompliziert zu machen.


```
public E remove(int index){

           Wrapper temp;
           Wrapper temp2;

            if (index < 0 || index >= size){
                throw new IndexOutOfBoundsException();
            }

            temp = this.first;

            for (int iRun = 0; iRun < index-1; iRun++){

                temp = temp.succ;
            }

            temp2 = this.first;

            for (int iRun = 0; iRun < index; iRun++){

                temp2 = temp2.succ;
            }

            temp.succ = temp2.succ;

            size--;

            return temp2.e;

    }
```


----------



## SlaterB (4. Mai 2011)

für temp2 brauchst du keine neue Schleife, temp2 ist genau temp.succ

auch die erste Schleife ist wohl nicht nötig, verwende doch deine Methode get(int index)

edit: ok, die liefert nur das Element, dann doch die Schleife,
wenn du aber irgendwann 5x die Schleife stehen hast, dann besser eine Hilfsmethode schreiben, 
private Wrapper getWrapper(int index)


----------



## rogue (4. Mai 2011)

Danke für die weitere Antwort. Hat mir sehr weitergeholfen.

Ich hab nur noch ein Problem mit boolean remove. Ist mit Objects immer genau einer der Wrapper gemeint?

Soll ich dann mit get() in der Main einen herausfischen und diesen dann löschen?


----------



## Final_Striker (4. Mai 2011)

In der Regel schon, du könntest aber natürlich auch zuerst prüfen ob es sich dabei um ein Wrapper-Objekt handelt.

Ansonsten muss du die Liste nach dem Objekt durchsuchen und falls es sich in der Liste befinden, das Objekt aus der Liste löschen.


----------

