2010-11-17 164 views
1

我的一个朋友想让我把他的代码转换成一个双向链表,尽管我并不熟悉它。我查找了双重链表,但我无法告诉他的代码如何处理它。我不是主程序员。你有什么建议吗?单向链表到双向链表

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

你的朋友是你的CS老师吗? – shoebox639 2010-11-17 19:59:58

+5

这功课吗?为什么你的“朋友”不能自己发布这个问题? – MAK 2010-11-17 20:01:15

+0

@ shoebox639我希望我可以再次让你高兴 – 2010-11-17 20:12:35

回答

1

我不明白这个问题。如果这是作业,你应该这么说 - 社区规则!简单解释,无论:

链表是用下面的结构,...好,结构:

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

每一个“链接”中的“产业链”包含了一些数据和方法找到链中的下一个项目。正如你所说,这是一个单独的链表。

双向链表是一个非常相似的结构,只有链中的每个链接既包含查找下一个项目的方法,也包含查找前一个项目的方法。如果你需要能够以两种方式走列表,你需要这种结构。

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

Ooookay的“图纸”是可怕的。您可以查看双向链接列表与谷歌查询是什么,并获得更好的信息,第二个想法,但哦。

+0

事实上,显然功能标签现在正式被阻止(至少这是某人告诉我的)。官方的建议是公开承认它是作业,但要避免'元'标签(与问题内容无关)。 – Crisfole 2010-11-17 20:05:22

+0

哦,看看!编辑,谢谢。很高兴知道。 – slezica 2010-11-17 20:09:36

0

每个节点需要一个next以及一个previous占位符,它是一个双向链接列表。在Java中是

0

LinkedList是一个双向链表。你为什么想要自己创建一个?

0

听起来像家庭作业。这会让你开始。

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

基本上,在单链表每个节点都有一个指针到下一个节点。在双向链表中,有指向下一个和前一个的指针。请小心指针如何在列表的开头和结尾工作。