DoubleLinkedList -Projekt: Beispieleingabe

Question

Ich arbeite derzeit an einem doppelt verknüpften Listenprojekt in meinem College -Java -Kurs. Ich verstehe das Konzept von doppelt verknüpften Listen, verknüpften Listen und Listen. Ich habe jedoch große Probleme, mein Programm zu schreiben, da ich nicht sicher bin, wie ich die Daten erstellen kann, die ich in meinen Methoden ändern muss. Unser Professor gibt uns normalerweise den Beitrag, den er verwenden wird, aber diesmal nicht, und ich kann es in meiner Forschung nicht herausfinden.

Ich nehme an, meine Hauptfrage ist, könnte jemand einen Code schreiben, mit dem ich anfangen kann zu arbeiten und zu verstehen, was meine Methoden benötigen, um besser zu werden?

Hier ist, was ich bisher habe. (Grundsätzlich nur das Override -Skelett ..)

Vielen Dank für jede Hilfe.

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

public class DoublyLinkedList<E> implements List<E>{

DoublyLinkedListNode header;

public static void main(String[] args) {

}
public boolean add(E e) {
    return false;
}
public void add(int index, E element) {

}
public boolean addAll(Collection<? extends E> c) {
    return false;
}
public void clear() {
    header=null;
}
public boolean contains(Object o) {
    return false;
}
public E get(int index) {
    return null;
}
public int indexOf(Object o) {
    return 0;
}
public boolean isEmpty() {
    return header == null;
}
public int lastIndexOf(Object o) {
    return 0;
}
public ListIterator<E> listIterator() {
    return null;
}
public boolean remove(Object o) {
    return false;
}
public E remove(int index) {
    return null;
}
public int size() {
    return 0;
}
public Object[] toArray() {
    return null;
}
private class DoublyLinkedListNode{
    DoublyLinkedListNode next;
    DoublyLinkedListNode last;
    E contents;
}

//extra credit
private class DoublyLinkedListItr  implements java.util.ListIterator{

    public void add(Object arg0) {

    }
    public boolean hasNext() {

        return false;
    }
    public boolean hasPrevious() {

        return false;
    }
    public Object next() {

        return null;
    }
    public int nextIndex() {

        return 0;
    }
    public Object previous() {

        return null;
    }
    public int previousIndex() {

        return 0;
    }
    public void remove() {

    }
    public void set(Object arg0) {

    }

}
public ListIterator<E> listIterator(int index) {
    throw new UnsupportedOperationException("not implemented");
}
public <T> T[] toArray(T[] a) {
    throw new UnsupportedOperationException("not implemented");
}
public List<E> subList(int fromIndex, int toIndex) {
    throw new UnsupportedOperationException("not implemented");
}
public boolean retainAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented");
}
public E set(int index, E element) {
    throw new UnsupportedOperationException("not implemented");
}
public boolean removeAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented");
}
public boolean addAll(int index, Collection<? extends E> c) {
    throw new UnsupportedOperationException("not implemented");
}
public Iterator<E> iterator() {
    throw new UnsupportedOperationException("not implemented");
}
public boolean containsAll(Collection<?> c) {
    throw new UnsupportedOperationException("not implemented");
}

}

Answer 1

Zum Erstellen der Daten finden Sie hier der Snippet:

public static void main(String[] args) {
  DoublyLinkedList<String> doublyLinkedList = new DoublyLinkedList<String>();
  doublyLinkedList.add("Hello");
  doublyLinkedList.add("World");
  // If you want to store int
  DoublyLinkedList<Integer> dlli = new DoublyLinkedList<Integer>();
  dlli.add(new Integer(10));
  dlli.add(new Integer(5));
}

Ich hoffe, das ist es, wonach Sie suchen.

Answer 2

Erstellen Sie einen Knoten und speichern Sie den Wert darin.

Wenn der Header NULL ist, beziehen Sie sich auf den Kopfball auf Ihren neuen Knoten.

Wenn der Header nicht null ist, nehmen Sie den Knoten auf, auf den Sie auf den Knoten gerichtet sind, und solange das nächste Mal nicht null ist, nehmen Sie den Knoten, auf den als nächstes verwiesen wird. Wenn Sie als nächstes null sind, befinden Sie sich am Ende der Liste, nehmen Sie die nächste Referenz und lassen Sie sich auf Ihren neu erstellten Knoten verweisen. Nehmen Sie dann die letzte (ich hätte es vorher bezeichnet) Ihres neuen Knotens und lassen Sie ihn auf Ihren gefundenen Knoten (Ende der Liste) verweisen.

Das sollte dir loslegen.