使用java将单链表转换为双链表

我理解LinkedList和单/双链表的概念。一、 但是我不明白如何在我的代码中实现它

我必须将此单列列表转换为双链接列表：

public class MyLinkedList<E> extends MyAbstractList<E> {
  private Node<E> head, tail;

  /** Create a default list */
  public MyLinkedList() {
  }

  /** Create a list from an array of objects */
  public MyLinkedList(E[] objects) {
    super(objects);
  }

  /** Return the head element in the list */
  public E getFirst() {
    if (size == 0) {
      return null;
    }
    else {
      return head.element;
    }
  }

  /** Return the last element in the list */
  public E getLast() {
    if (size == 0) {
      return null;
    }
    else {
      return tail.element;
    }
  }

  /** Add an element to the beginning of the list */
  public void addFirst(E e) {
    Node<E> newNode = new Node<E>(e); // Create a new node
    newNode.next = head; // link the new node with the head
    head = newNode; // head points to the new node
    size++; // Increase list size

    if (tail == null) // the new node is the only node in list
      tail = head;
  }

  /** Add an element to the end of the list */
  public void addLast(E e) {
    Node<E> newNode = new Node<E>(e); // Create a new for element e

    if (tail == null) {
      head = tail = newNode; // The new node is the only node in list
    }
    else {
      tail.next = newNode; // Link the new with the last node
      tail = tail.next; // tail now points to the last node
    }

    size++; // Increase size
  }


  @Override /** Add a new element at the specified index 
   * in this list. The index of the head element is 0 */
  public void add(int index, E e) {
    if (index == 0) {
      addFirst(e);
    }
    else if (index >= size) {
      addLast(e);
    }
    else {
      Node<E> current = head;
      for (int i = 1; i < index; i++) {
        current = current.next;
      }
      Node<E> temp = current.next;
      current.next = new Node<E>(e);
      (current.next).next = temp;
      size++;
    }
  }

  /** Remove the head node and
   *  return the object that is contained in the removed node. */
  public E removeFirst() {
    if (size == 0) {
      return null;
    }
    else {
      Node<E> temp = head;
      head = head.next;
      size--;
      if (head == null) {
        tail = null;
      }
      return temp.element;
    }
  }

  /** Remove the last node and
   * return the object that is contained in the removed node. */
  public E removeLast() {
    if (size == 0) {
      return null;
    }
    else if (size == 1) {
      Node<E> temp = head;
      head = tail = null;
      size = 0;
      return temp.element;
    }
    else {
      Node<E> current = head;

      for (int i = 0; i < size - 2; i++) {
        current = current.next;
      }

      Node<E> temp = tail;
      tail = current;
      tail.next = null;
      size--;
      return temp.element;
    }
  }

  @Override /** Remove the element at the specified position in this 
   *  list. Return the element that was removed from the list. */
  public E remove(int index) {   
    if (index < 0 || index >= size) {
      return null;
    }
    else if (index == 0) {
      return removeFirst();
    }
    else if (index == size - 1) {
      return removeLast();
    }
    else {
      Node<E> previous = head;

      for (int i = 1; i < index; i++) {
        previous = previous.next;
      }

      Node<E> current = previous.next;
      previous.next = current.next;
      size--;
      return current.element;
    }
  }

  @Override /** Override toString() to return elements in the list */
  public String toString() {
    StringBuilder result = new StringBuilder("[");

    Node<E> current = head;
    for (int i = 0; i < size; i++) {
      result.append(current.element);
      current = current.next;
      if (current != null) {
        result.append(", "); // Separate two elements with a comma
      }
      else {
        result.append("]"); // Insert the closing ] in the string
      }
    }

    return result.toString();
  }

  @Override /** Clear the list */
  public void clear() {
    size = 0;
    head = tail = null;
  }

  @Override /** Return true if this list contains the element e */
  public boolean contains(E e) {
    System.out.println("Implementation left as an exercise");
    return true;
  }

  @Override /** Return the element at the specified index */
  public E get(int index) {
    System.out.println("Implementation left as an exercise");
    return null;
  }

  @Override /** Return the index of the head matching element in 
   *  this list. Return -1 if no match. */
  public int indexOf(E e) {
    System.out.println("Implementation left as an exercise");
    return 0;
  }

  @Override /** Return the index of the last matching element in 
   *  this list. Return -1 if no match. */
  public int lastIndexOf(E e) {
    System.out.println("Implementation left as an exercise");
    return 0;
  }

  @Override /** Replace the element at the specified position 
   *  in this list with the specified element. */
  public E set(int index, E e) {
    System.out.println("Implementation left as an exercise");
    return null;
  }

  @Override /** Override iterator() defined in Iterable */
  public java.util.Iterator<E> iterator() {
    return new LinkedListIterator();
  }

  private void checkIndex(int index) {
    if (index < 0 || index >= size)
      throw new IndexOutOfBoundsException
        ("Index: " + index + ", Size: " + size);
  }

  private class LinkedListIterator 
      implements java.util.Iterator<E> {
    private Node<E> current = head; // Current index 

    @Override
    public boolean hasNext() {
      return (current != null);
    }

    @Override
    public E next() {
      E e = current.element;
      current = current.next;
      return e;
    }

    @Override
    public void remove() {
      System.out.println("Implementation left as an exercise");
    }
  }

  private static class Node<E> {
    E element;
    Node<E> next;

    public Node(E element) {
      this.element = element;
    }
  }
}

公共类MyLinkedList扩展了MyAbstractList{
私有节点头、尾；
/**创建默认列表*/
公共MyLinkedList（）{
}
/**从对象数组创建列表*/
公共MyLinkedList（E[]对象）{
超级（对象）；
}
/**返回列表中的head元素*/
公共E getFirst（）{
如果（大小==0）{
返回null；
}
否则{
返回头元素；
}
}
/**返回列表中的最后一个元素*/
公共E getLast（）{
如果（大小==0）{
返回null；
}
否则{
返回尾元素；
}
}
/**将元素添加到列表的开头*/
公共无效地址优先（E）{
Node newNode=新节点（e）；//创建一个新节点
newNode.next=head；//将新节点链接到head
head=newNode；//head指向新节点
size++；//增加列表大小
if（tail==null）//新节点是列表中唯一的节点
尾=头；
}
/**将元素添加到列表的末尾*/
公共无效地址（E）{
Node newNode=新节点（e）；//为元素e创建一个新节点
if（tail==null）{
head=tail=newNode；//新节点是列表中唯一的节点
}
否则{
tail.next=newNode；//将新节点与最后一个节点链接
tail=tail.next；//tail现在指向最后一个节点
}
size++；//增加大小
}
@Override/**在指定索引处添加新元素
*在此列表中。head元素的索引为0*/
公共无效添加（整数索引，E）{
如果（索引==0）{
第一（e）；
}
否则如果（索引>=大小）{
addLast（e）；
}
否则{
节点电流=头；
对于（int i=1；i=大小）{
返回null；
}
else if（索引==0）{
return removeFirst（）；
}
else if（索引==大小-1）{
返回removeLast（）；
}
否则{
节点前一个=头；
对于（int i=1；i=大小）
抛出新的IndexOutOfBoundsException
（“索引：+Index+”，大小：+Size）；
}
私有类链接标识符
实现java.util.Iterator{
私有节点当前=头；//当前索引
@凌驾
公共布尔hasNext（）{
返回（当前！=null）；
}
@凌驾
公共教育{
E=当前元素；
当前=当前。下一步；
返回e；
}
@凌驾
公共空间删除（）{
System.out.println（“作为练习的实现”）；
}
}
专用静态cla
  private static class Node<E> {
    E element;
    Node<E> next;
    Node<E> previous;


    public Node(E element) {
      this.element = element;
    }