DoublyLinkedList问题向后传播

时间:2016-10-28 10:26:48

标签: java arraylist nullpointerexception linked-list doubly-linked-list

我有一个完成DoublyLinkList任务的任务,我在使用其中两个方法时遇到了一些困难。我获得了MyList和MyAbstractList的代码,并被告知使用我的DoublyLinkedList扩展MyAbstractList。我不允许更改MyList或MyAbstractList。

以下是我提供的MyList代码:

   public interface MyList<E extends Comparable<E>>  {

      /** Return true if this list contains no elements */
      public boolean isEmpty();

      /** Return the number of elements in this list */
      public int size();

      /** Add a new element at the proper point */
      public void add(E e);

      /** Clear the list */
      public void clear();

      /** Return true if this list contains the element */
      public boolean contains(E e);

      /** Return the element from this list at the specified index */
      public E get(int index);

      /** Return the first element in the list */
      public E getFirst();

      /** Return the last element in the list */
      public E getLast();

      /** Return the index of the first matching element in this list.
       *  Return -1 if no match. */
      public int indexOf(E e);

      /** Return the index of the last matching element in this list
       *  Return -1 if no match. */
      public int lastIndexOf(E e);

      /** Remove the first occurrence of the element o from this list.
       *  Shift any subsequent elements to the left.
       *  Return true if the element is removed. */
      public boolean remove(E e);

      /** Remove the element at the specified position in this list
       *  Shift any subsequent elements to the left.
       *  Return the element that was removed from the list. */
      public boolean remove(int index);

      /** Remove the first element in the list, return true if done, false if list is empty */
      public boolean removeFirst();

      /** Remove the Last element in the list, return true if done, false if list is empty */
      public boolean removeLast();

      /** Replace the element at the specified position in this list
       *  with the specified element and return true if done, false if index out of range. */
      public boolean set(int index, E e);

    }

这是我为MyAbstractList提供的代码:

public abstract class MyAbstractList<E extends Comparable<E>> implements MyList<E> {
  protected int size = 0; // The size of the list

  /** Create a default list */
  protected MyAbstractList() {
  }

  /** Create a list from an array of objects */
  public MyAbstractList(E[] objects) {
      for (int i = 0; i < objects.length; i++)
          add(objects[i]);
  }

 @Override /** Return true if this list contains no elements */
  public boolean isEmpty() {
    return size == 0;
  }

  @Override /** Return the number of elements in this list */
  public int size() {
    return size;
  }

}

最后这是我的MyDoublyLinkedList代码:

import java.util.ArrayList;
public class MyDoublyLinkedList<E extends Comparable<E>> extends MyAbstractList<E>
{
    int size =0;
    Node<E> head = null;
    Node<E> current = null;
    Node<E> tail = null;
    public MyDoublyLinkedList() {

    }

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

    @Override
      public boolean isEmpty()
      {
        return size == 0;
      }

    @Override
      public int size()
      {
          return size;
        }
    /** Add a new element at the proper point */
    @Override
      public void add(E e)
      {
        Node<E> newNode = new Node<E>(e);
        if (tail == null) {
            head = tail = newNode;

        } 
        else //if (head != null)
        {
            tail.next = newNode;
            tail = newNode;

        }     

        size++;

    }

    @Override
      public void clear()
      {
          size = 0;
          head = tail = null;
        }

    @Override
      public boolean contains(E e)
      {
      Node<E> current = head;
      for (int i = 0; i < size; i++) {
        if (current.element.equals(e))
          return true;
        current = current.next;
      }

      return false;
        }

    @Override
      public E get(int index)
      {
      if (index < 0 || index > size - 1)
        return null;

      Node<E> current = head;
      for (int i = 0; i < index; i++)
        current = current.next;

      return current.element;
        }

    @Override
      public E getFirst()
      {
        if (size == 0) {
          return null;
        }
        else {
          return head.element;
        }
        }

    @Override
      public E getLast()
      {
        if (size == 0) {
          return null;
        }
        else {
          return tail.element;
        }
        }

    @Override
      public int indexOf(E e)
      {
          Node<E> current = head;
      for (int i = 0; i < size; i++) {
        if (current.element.equals(e))
          return i;
        current = current.next;
      }

      return -1;
        }

    @Override
      public int lastIndexOf(E e)
      {
      int lastIndex = -1;
      Node<E> current = head;
      for (int i = 0; i < size; i++) {
        if (current.element.equals(e))
          lastIndex = i;
        current = current.next;
      }

      return lastIndex;
        }
    /** Remove the first occurrence of the element o from this list.
    *  Shift any subsequent elements to the left.
    *  Return true if the element is removed. */
    @Override
      public boolean remove(E e)
      {
        int index = indexOf(e);
        if (index != -1) {
            return remove(index);
        } else {
            return false;
        }



        }
    /** Remove the element at the specified position in this list
    *  Shift any subsequent elements to the left.
    *  Return the element that was removed from the list. */
    @Override
      public boolean remove(int index)
      {
        if (index < 0 || index >= size) {
          return false;
        }
        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 true;
        }
        }

    @Override
      public boolean removeFirst()
      {
          if (size == 0) {
          return false;
        }
        else {
          Node<E> temp = head;
          head = head.next;
          size--;
          if (head == null) {
            tail = null;
          }
          return true;
        }
        }

    @Override
      public boolean removeLast()
      {
       if (size == 0) {
              return false;
        }
        else if (size == 1) {
          Node<E> temp = head;
          head = tail = null;
          size = 0;
          return true;
        }
        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 true;
        }
    }
    @Override
      public boolean set(int index, E e)
      {
          if (index < 0 || index > size - 1)
            return false;

          Node<E> current = head;
          for (int i = 0; i < index; i++)
            current = current.next;

          E temp =  current.element;
          current.element = e;

          return true;
        }

    @Override
    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();
    }

        public String toStringBack()
    {
        StringBuilder result = new StringBuilder("[");

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

        return result.toString();
    }

    public void add(int index, E e)
    {

       if (index ==0) {
          addFirst(e);// The new node is the only node in list
        }
        else if(index > size)
        {
            addLast(e);//The index location was bigger than size
        }
        else
        {
            Node<E> current = getAtIndex(index-1);
            Node<E> temp = current.next;
            current.next = new Node<E>(e);
            (current.next).next = temp;
            size++;
       }

    }

    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;

    }

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

    protected Node<E> getAtIndex(int index)
    {
         int count;
         if (index < 0 || index > size - 1)
         return null;
         Node<E> temp = null;
         if(index <= (size/2))
           {
            count = -1;
            temp = head;
            while(++count <= index){
                temp = temp.next;
              }
          }
          else if (index > (size/2))
          {
            count = size;
            temp = tail;
            while(--count >= index){
                temp = temp.previous; //--> this is Where the null pointer exception occurs 
            }
        }
          return temp;
    }
    private static class Node<E>{
        E element;
        Node<E> next;
        Node<E> previous;
        public Node(E element){
            this.element = element;
            next = null;
            previous = null;
        }
      }
 }

当我运行add(int index,E e)方法时,我在getAtIndext()方法中收到一个空指针异常。当我更改当前位置时,我也遇到了使添加(E e)方法正确添加的问题。这些方法都是因为我被要求使用它们。不允许使用迭代器,但它们会很好。我使用Bluj作为编译器。请告诉我你有什么问题。

谢谢

编辑:我确实知道Null Pointer Exception是什么,我无法弄清楚为什么这会返回null。节点“当前”应指向结尾,然后返回列表,直到它到达索引位置。这只发生在我尝试在列表的后半部分添加节点时。错误发生在temp = temp.previous; 堆栈跟踪是: myDoublyLinkedList.getAtIndex(MyDoublyLinkedList.java:345)的MyDoublyLinkedList.add(MyDoublyLinkedList.java:289)中的java.lang.NullPointerException,位于TestMyDoublyLinkedList.main(TestMyDoublyLinkedList.java:50)

编辑:我弄明白了这个问题。 add()和getAtIndex函数正常运行。当我运行测试时,抛出Null Pointer Exception的函数将它抛出到位置8.它在前几个节点中循环很好,但在节点8处死亡

1 个答案:

答案 0 :(得分:0)

add()方法中插入时,您永远不会分配previous,因此所有节点都为空。