Doppelt Verkettete Liste

[GroovyChuc]

Ich hab mir jetzt mit dem Wissen aus der Vorlesung eine einfach verkettete Liste zusammengebaut.
Nun einige Fragen:
1. Funktioniert das überhaupt?
2. Wieso brauche ich bei boolean contains (Test ob ein Objekt in der Liste ist) eine public und eine private Methode mit unterschiedlichen Paramentern?

import java.util.NoSuchElementException;

public class LinkedList<T> {
	static class ListElement<T> {

		private ListElement<T> next;
		private T data;

		public ListElement(T data) {
			this.data = data;
		}
	}

	private ListElement<T> head;
	private ListElement<T> tail;

	public LinkedList() {
		head = null;
		tail = null;
	}

	public void addFirst(T data) {
		ListElement<T> e = new ListElement<T>(data);
		if (head == null) {
			head = tail = e;
		} else {
			e.next = head;
			head = e;
		}
	}

	public void addLast(T data) {
		ListElement<T> e = new ListElement<T>(data);
		if (head == null) {
			head = tail = e;
		} else {
			tail.next = e;
			tail = e;
		}
	}

	private ListElement<T> get(ListElement<T> currentHead, int index) {
		if (index == 0) {
			return currentHead;
		} else {
			return get(currentHead.next, index - 1);
		}
	}

	public boolean contains(T data) {
		return contains(head, data);
	}

	private boolean contains(ListElement<T> currentHead, T data) {
		if (currentHead == null) {
			return false;
		} else if (currentHead.data.equals(data)) {
			return true;
		} else {
			return contains(currentHead.next, data);
		}
	}

	public T removeFirst() {
		T data;
		if (head == null) {
			throw new NoSuchElementException();
		} else if (head == tail) {
			data = head.data;
			head = tail = null;
		} else {
			data = head.data;
			head = head.next;
		}
		return data;
	}

	private T removeLast(ListElement<T> curr) {
		if (curr.next == tail) {
			tail = curr;
			T data = curr.next.data;
			curr.next = null;
			return data;
		} else {
			return removeLast(curr.next);
		}
	}
}

3. Wie kann ich das ganze in eine doppelt Verkettete Liste umbauen? (ohne Wächterelemente)
Im Prinzip muss ich ja dann noch zu dem bereits bestehende next, noch den previous Zeiger implementieren.
Beispielhaft für addFirst:

public void addFirst(T data) {
	ListElement<T> e = new ListElement<T>(data);
	if (head == null) {
		head = tail = e;
	} else {
                head.previous = e;
                e.next = head;
                e.previous = null;
		head = e;
	}
}

4. Contains müsste ich ja nicht ändern oder?

 

[SlaterB]

2.
für die Rekursion die vielen Parameter, nach außen unnötig, da eine schickere Kurzvariante

3.
genau

4.
richtig, manche brauchen das nicht wenn sie nur vorwärts laufen

 

[bERt0r]

Eine Liste rekursiv abzuarbeiten halte ich aber nicht für besonders sinnvoll. Das kriegt man mit einer While Schleife in einer Funktion auch hin und das viel verständlicher.

    public boolean contains(T data) {
        ListElement<T> act=head;
        while(act!=null)
        {
              if(act.data.equals(data))
                   {return true;}
              act=act.next;
        }
        return false;
    }