2010-11-17 7 views
1

Un de mes amis veut que je convertisse son code en une liste doublement chaînée, même si je ne la connais pas du tout. J'ai recherché des listes doublement liées mais je ne peux pas dire par son code quoi en faire. Je ne suis pas un programmeur maître. Avez-vous des suggestions?Liste de liens simples à une liste doublement chaînée

import java.util.Collection; 

import java.util.List; 


class SinglyLinkedList<E> implements List<E> { 



private class SinglyLinkedListNode<T> { 



    T data; 

    SinglyLinkedListNode<T> next; 



    public SinglyLinkedListNode() { 

     this(null, null); 

    } 



    public SinglyLinkedListNode(T data) { 

     this(data, null); 

    } 



    public SinglyLinkedListNode(T d, SinglyLinkedListNode<T> n) { 

     data = d; 

     next = n; 

    } 



    public boolean equals(Object o) { 

     if (data != null && o != null) { 

      return data.equals(((SinglyLinkedListNode) o).data); 

     } else { 

      return (data == null && o == null); 

     } 

    } 

} 

private SinglyLinkedListNode<E> list, last; 

private int size; 



public SinglyLinkedList() { 

    clear(); 

} 



public void clear() { 

    list = last = null; 

    size = 0; 

} 



public boolean contains(Object o) { 

    SinglyLinkedListNode<E> t = list; 

    while (t != null) { 

     if (t.data == null) { 

      if (o == null) { 

       return true; 

      } 

     } else if (t.data.equals(o)) { 

      return true; 

     } 

     t = t.next; 

    } 

    return false; 

} 



public boolean add(E e) { 

    SinglyLinkedListNode<E> n = new SinglyLinkedListNode<E>(e); 

    if (isEmpty()) { 

     list = last = n; 

    } else { 

     last = last.next = n; 

    } 

    size++; 

    return true; 

} 



public void add(int index, E e) { 

    int currSize = size(); 

    if (index < 0 || index > currSize) { 

     throw new IndexOutOfBoundsException(

       "Index: " + index + ", Size: " + size()); 

    } 

    if (isEmpty()) // index must == 0 

    { 

     list = last = new SinglyLinkedListNode<E>(e); 

    } else { 

     if (index == 0) { 

      list = new SinglyLinkedListNode<E>(e, list); 

     } else { 

      SinglyLinkedListNode<E> n = list; 

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

       n = n.next; 

      } 

      n.next = new SinglyLinkedListNode<E>(e, n.next); 

      if (index == currSize) { 

       last = n.next; 

      } 

     } 

    } 

    size++; 

} 



public boolean equals(SinglyLinkedList<E> e) { 


    SinglyLinkedListNode<E> e1 = list, e2 = e.list; 

    try { 

     for (int i = 1; i <= size(); i++) { 

      if (!e1.equals(e2)) { 

       return false; 

      } 

      e1 = e1.next; 

      e2 = e2.next; 

     } 

    } catch (NullPointerException ex) { 

     return false; 

    } 

    return true; 

} 



public E get(int index) { 

    if (index < 0 || index >= size()) { 

     throw new IndexOutOfBoundsException(

       "Index: " + index + ", Size: " + size()); 

    } 

    SinglyLinkedListNode<E> n = list; 

    int i = 0; 

    for (; i < index; i++) { 

     n = n.next; 

    } 

    return n.data; 

} 



@SuppressWarnings("unchecked") 

public int indexOf(Object o) { 

    SinglyLinkedListNode<E> n = list; 

    int i = 0; 

    while (n != null) { 

     if ((o == null 

       ? (n.data == null) 

       : (((E) o).equals(n.data)))) { 

      return i; 

     } 

     n = n.next; 

     i++; 

    } 

    return -1; 

} 



public boolean isEmpty() { 

    return list == null; 

} 



public E remove(int index) { 

    if (index < 0 || index >= size()) { 

     throw new IndexOutOfBoundsException(

       "Index: " + index + ", Size: " + size()); 

    } 

    SinglyLinkedListNode<E> n = list, prevNode = null; 

    int i = 0; 

    while (true) { 

     if (index == i) { 

      if (n == list) // removing first node 

      { 

       list = list.next; 

      } else { 

       prevNode.next = n.next; 

      } 

      if (n == last) { 

       last = prevNode; 

      } 

      size--; 

      return n.data; 

     } 

     prevNode = n; 

     n = n.next; 

     i++; 

    } 

} 



@SuppressWarnings("unchecked") 

public boolean remove(Object o) { 

    SinglyLinkedListNode<E> n = list, prevNode = null; 

    while (n != null) { 

     if ((o == null 

       ? (n.data == null) 

       : (((E) o).equals(n.data)))) { 

      if (n == list) //removing first node 

      { 

       list = list.next; 

      } else { 

       prevNode.next = n.next; 

      } 

      if (n == last) { 

       last = prevNode; 

      } 

      size--; 

      return true; 

     } 

     prevNode = n; 

     n = n.next; 

    } 

    return false; 

} 



public int size() { 

    return size; 

} 



public String toString() { 

    String s = "(("; 

    SinglyLinkedListNode<E> t = list; 

    if (t != null) { 

     while (t.next != null) { 

      s += t.data + ", "; 

      t = t.next; 

     } 

     s += last.data; 

    } 

    return s + "))"; 

} 
+14

Votre ami est-il votre professeur CS? – shoebox639

+5

Est-ce que ce sont les devoirs? Pourquoi votre «ami» ne peut-il pas poster cette question elle-même? – MAK

+0

@ shoebox639 Je souhaite pouvoir vous remettre en question –

Répondre

1

Je ne comprends pas le problème. Si c'est devoirs, vous devriez le dire - les règles de la communauté! Une explication rapide, peu importe:

Une liste chaînée est une structure avec ce qui suit, ... eh bien, structure:

DATA      |--> DATA 
REFERENCE TO NEXT ITEM ---| REFERENCE TO NEXT ITEM ---... 

Chaque « lien » dans la « chaîne » contient des données, et d'une manière pour localiser l'élément suivant dans la chaîne. C'est une liste unidirectionnelle, comme vous l'avez dit.

Une liste doublement chaînée est une structure très similaire, seul chaque lien de la chaîne contient à la fois un moyen de localiser l'élément suivant et un moyen de localiser l'élément précédent. Si vous devez être capable de parcourir la liste dans les deux sens, vous aurez besoin de ce type de structure.

|-> DATA      |--> DATA 
| REFERENCE TO NEXT ITEM ---| REFERENCE TO NEXT ITEM ---... 
---------------------------------- REFERENCE TO PREV ITEM 

Ooookay les "dessins" sont hideux. Vous pouvez rechercher ce qu'est une liste doublement liée avec une requête de Google et obtenir une meilleure information, à la réflexion, mais bon.

+0

En fait, apparemment l'étiquette de devoirs est maintenant déconseillée officiellement (du moins c'est ce que quelqu'un m'a dit). La recommandation officielle est d'admettre ouvertement que c'est un devoir, mais d'éviter les balises méta (qui n'ont rien à voir avec le contenu de la question). – Crisfole

+0

Oh, regarde ça! Edité, merci. Bon à savoir. – slezica

0

Regardez at this other question sur SO. Cela devrait vous aider à mieux comprendre la liste doublement chaînée.

0

Chaque noeud a besoin d'un next ainsi que d'un espace réservé previous pour que ce soit une liste doublement chaînée.

0

LinkedList en Java est une liste doublement liée. Pourquoi voudriez-vous en créer un par vous-même?

0

ressemble à des devoirs. Cela vous aidera à démarrer.

http://en.wikipedia.org/wiki/Doubly_linked_list

essentiellement, dans une liste chaînée chaque noeud a un pointeur vers le noeud suivant. Dans une liste doublement chaînée, il y a des pointeurs vers le suivant et le précédent. Méfiez-vous du fonctionnement des pointeurs au début et à la fin de la liste.