DoublyLinkedList Projet: Exemple d'entrée

Question

Je travaille actuellement sur un projet lié Liste Doublement dans mon cours java collège. Je comprends le concept des listes doublement chaînées, listes chaînées, et les listes. Cependant, je vais avoir beaucoup de mal à écrire mon programme comme je ne suis pas sûr de savoir comment créer les données que je dois modifier mes méthodes. Notre professeur nous donne généralement l'entrée qu'il utilisera, mais n'a pas cette fois-ci, et je ne peux pas sembler figurer dans mes recherches.

Je suppose que ma principale question est quelqu'un pourrait écrire un code pour moi de commencer à travailler avec et commencer à comprendre ce que mes méthodes doivent être faire mieux?

Voici ce que j'ai jusqu'à présent. (Fondamentalement juste le squelette de priorité ..)

Merci beaucoup pour toute aide.

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

Pour créer les données ici est l'extrait:

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));
}

J'espère que c'est ce que vous recherchez.

Answer 2

Créer un nœud et stocker la valeur en elle.

Si la tête est nulle, ont en-tête de votre nouveau nœud la référence.

Si la tête est non nul, prenez le nœud pointé, et aussi longtemps que la prochaine n'est pas nul, prenez le nœud référencé par suivant. Si suivant est nul, vous êtes à la fin de la liste, prenez la référence suivante et ont référencer votre nouveau nœud. Ensuite, prendre la dernière (je l'ai appelé précédent) référence de votre nouveau nœud et le faire référence à votre noeud TROUVÉE (fin de la liste).

Cela devrait vous aider à démarrer.