Hilfe, LinkedList

Bin gerade bei, eine LinkedList selber zu schreiben, um sie später zu invertieren. Aber eine Ausgabe ist noch falsch. Könnt ihr mir helfen?

Java:
package ownjavalinkedlist.ownjavalinkedlist;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class OwnJavaLinkedList<T> implements List<T> {
	OwnJavaLinkedList<T> end = this;
	OwnJavaLinkedList<T> next = null;
	OwnJavaLinkedList<T> prev = null;
	T t1 = null;
	boolean empty = true;

	public static void main(String[] args) {
		OwnJavaLinkedList<Integer> ll = new OwnJavaLinkedList<Integer>();
		ll.add(1);
		ll.add(2);
		ll.add(3);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3));
		System.out.println(ll.contains(1));
		System.out.println(ll.contains(0));
		ll.remove((Object) 2);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3));
		System.out.println(ll.contains(1));
		System.out.println(ll.contains(0));
		ll.remove((Object) 3);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3));
		System.out.println(ll.contains(1));
		System.out.println(ll.contains(0));
		ll.remove((Object) 1);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3));
		System.out.println(ll.contains(1));
		System.out.println(ll.contains(0));
		System.out.println();
		ll.add(2);
		ll.add(3);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3));
		ll.remove((Object) 2);
		ll.add(4);
		System.out.println(ll.contains(2));
		System.out.println(ll.contains(3)); // hier sollte 'true' ausgegeben werden
		System.out.println(ll.contains(4));
		ll.remove((Object) 3);
		ll.remove((Object) 4);
		System.out.println(ll.isEmpty());
	}

	public int size() {
		int a = 0;
		OwnJavaLinkedList<T> c = this;
		while (c != null) {
			a++;
			c = c.next;
		}
		return a;
	}

	public boolean isEmpty() {
		return empty;
	}

	public boolean contains(Object o) {
		OwnJavaLinkedList<T> c = this;
		while (c != null) {
			if (o.equals(c.t1))
				return true;
			c = c.next;
		}
		return false;
	}

	public Iterator<T> iterator() {
		return new Iterator<T>() {
			OwnJavaLinkedList<T> c = OwnJavaLinkedList.this;

			public boolean hasNext() {
				return c.empty;
			}

			public T next() {
				T t = c.t1;
				c = c.next;
				return t;
			}
		};
	}

	public Object[] toArray() {
		// TODO
		return null;
	}

	public <T> T[] toArray(T[] a) {
		// TODO
		return null;
	}

	public boolean add(T e) {
		if (empty || end.empty) {
			t1 = e;
			empty = false;
		} else {
			end.next = new OwnJavaLinkedList<T>();
			end.next.prev = end;
			end.next.t1 = e;
			end.next.empty = false;
			end = end.next;
		}
		return true;
	}

	public boolean remove(Object o) {
		OwnJavaLinkedList<T> c = this;
		while (c != null) {
			if (o.equals(c.t1)) {
				if (c == this) {
					clear();
				} else {
					if (c.prev != null)
						c.prev.next = c.next;
					if (c.next != null)
						c.next.prev = c.prev;
					if (c == end)
						end = c.prev;
				}
				return true;
			}
			c = c.next;
		}
		return false;
	}

	public boolean containsAll(Collection<?> c) {
		// TODO
		return false;
	}

	public boolean addAll(Collection<? extends T> c) {
		// TODO
		return false;
	}

	public boolean addAll(int index, Collection<? extends T> c) {
		// TODO
		return false;
	}

	public boolean removeAll(Collection<?> c) {
		// TODO
		return false;
	}

	public boolean retainAll(Collection<?> c) {
		// TODO
		return false;
	}

	public void clear() {
		end = this;
		next = null;
		prev = null;
		t1 = null;
		empty = true;
	}

	public T get(int index) {
		// TODO
		return null;
	}

	public T set(int index, T element) {
		// TODO
		return null;
	}

	public void add(int index, T element) {
		// TODO

	}

	public T remove(int index) {
		// TODO
		return null;
	}

	public int indexOf(Object o) {
		// TODO
		return 0;
	}

	public int lastIndexOf(Object o) {
		// TODO
		return 0;
	}

	public ListIterator<T> listIterator() {
		// TODO
		return null;
	}

	public ListIterator<T> listIterator(int index) {
		// TODO
		return null;
	}

	public List<T> subList(int fromIndex, int toIndex) {
		// TODO
		return null;
	}
}
 
Das Problem ist in deiner remove(Object) Implementierung. Wenn der zu entfernende Wert gleich am Anfang der Liste ist, clear()-st du die Liste einfach, statt das erste Listenelement nur auszuhängen:
Java:
public boolean remove(Object o) {
    OwnJavaLinkedList<T> c = this;
    while (c != null) {
        if (o.equals(c.t1)) {
            if (c == this) { // <- ist true für das erste Element
                clear(); // <- FALSCH!
In Zukunft einfach einen Debugger verwenden, und die Methodenaufrufe step-by-step durchgehen. Damit findest du solche Fehler in null-komma-nix. Damit habe ich den Fehler auch in ungefähr 10 Sekunden gefunden.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben