带有 LinkedLists 和节点的 Java 堆空间

Question

对于计算机科学，我正在编写一个程序来保持头部的“尾部”，一个节点，以便我可以在节点/链接列表中添加和删除。这并不完全困难，但我遇到了一个让我哭的问题。我遇到了 java 堆空间（内存不足）。

这是我的代码：

import java.util.NoSuchElementException;

/**
A linked list is a sequence of nodes with efficient
element insertion and removal. This class 
contains a subset of the methods of the standard
java.util.LinkedList class.
 */
public class LinkedList
{  
    private Node head;
    private int currentSize;
    private Node tails;
    /** 
    Constructs an empty linked list.
     */
    public LinkedList()
    {  
        head = null;
        tails = null;
        currentSize = 0;
    }

    /**
    Adds an element to the front of the linked list.
    @param element the element to add
     */
    public void addFirst(Object element)
    {  
        Node newNode = new Node();
        if(head == null){
            tails = newNode;
        }
        newNode.data = element;
        currentSize++;
        newNode.next = head;
        head = newNode;
    }

    /**
    Removes the head element in the linked list.
    @return the removed element
     */
    public Object removeFirst(){  
        if (head == null) 
            throw new NoSuchElementException();
        Object temp = head.data;
        head = head.next;
        if(tails.next == null)
            tails.next = head;

        currentSize--;
        return temp;
    }

    /**
    Returns the head element in the linked list.
    @return the head element in the linked list
     */
    public Object getFirst()
    {  
        if (head == null) 
            throw new NoSuchElementException();
        return head.data;
    }

    /**
    Returns the element at a given position in the linked list.
    @param index the element position
    @return the element at the given position
     */
    Object get(int index)
    {
        if (index < 0)
            throw new NoSuchElementException();

        Node current = head;
        int i = 0;

        while (current != null && i < index)
        {
            current = current.next;
            i++;
        }

        if (current == null)
            throw new NoSuchElementException();
        return current.data;
    }

    /**
    Computes the size of the linked list
    @return the number of elements in the list
     */
    public int size()
    { 
        //to be completed for lab 7.1 #2
        return currentSize;  // rewrite this, just makes it compile
    }

    /**
    Reverses all elements in a linked list.
     */
    public void reverse(){ 
       Node currentNode, nextNode, loopNode;
        if(head==null)
             return;
        currentNode=head;
        nextNode= head.next;
        loopNode = null;
       while(nextNode != null){
            currentNode.next = loopNode;
            loopNode= currentNode;
            currentNode=nextNode;
            nextNode =nextNode.next;
       }
       head = currentNode;
       head.next = loopNode;

}


    /**
    Adds an element to the end of the linked list.
    @param element the element to add
     */
    public void add(Object element){
        Node current = new Node();
        current.data = element;
        if(tails.next == null)
           tails.next = current;

       tails = head;
       currentSize ++;
    }    

    /**
    Returns an iterator for iterating through this list.
    Allows the use of the iterator outside of this class.
    @return an iterator for iterating through this list
     */
    public ListIterator listIterator()
    {  
        return new LinkedListIterator();
    }

    /**
    Returns a string representation of this list in brackets 
    separated by commas.
    @return a string of list elements.
     */
    public String toString()
    {  
        StringBuilder temp = new StringBuilder();
        ListIterator it = listIterator();
        while(it.hasNext()){
            temp.append(it.next());
            if(it.hasNext())
                temp.append(", ");
        }
        return temp.toString();    
    }

    private static class Node
    {  
        private Object data;
        private Node next;


    }

    private class LinkedListIterator implements ListIterator
    {              
        private Node position;
        private Node previous;

        /**
        Constructs an iterator that points to the front
        of the linked list.
         */
        public LinkedListIterator()
        {  
            position = null;
            previous = null;

        }

        /**
        Moves the iterator past the next element.
        @return the traversed element
         */
        public Object next()
        {  
            if (!hasNext())
                throw new NoSuchElementException();
            previous = position; // Remember for remove

            if (position == null)
                position = head;
            else
                position = position.next;

            return position.data;
        }

        /**
        Tests if there is an element after the iterator 
        position.
        @return true if there is an element after the iterator 
        position
         */
        public boolean hasNext()
        {  
            if (position == null)
                return head != null;
            else
                return position.next != null;
        }

        /**
        Adds an element before the iterator position
        and moves the iterator past the inserted element.
        @param element the element to add
         */
        public void add(Object element)
        {  
            if (position == null)
            {
                addFirst(element);
                position = head;
                tails = head;
            }
            else{  
                Node newNode = new Node();
                newNode.data = element;
                newNode.next = position.next;
                position.next = newNode;
                position = newNode;
                previous = position;
                tails = newNode;
            }
                currentSize ++;
        }

        /**
        Removes the last traversed element. This method may
        only be called after a call to the next() method.
         */
        public void remove()
        {  
            if (previous == position)
                throw new IllegalStateException();

            if (position == head)
            {
                removeFirst();
                currentSize --;
                tails = previous;
            }
            else 
            {  
                previous.next = position.next;
                currentSize --;
                tails = previous;
            }

            position = previous;

        }

        /**
        Sets the last traversed element to a different 
        data. 
        @param element the element to set
         */
        public void set(Object element)
        {
            if (position == null)
                throw new NoSuchElementException();
            position.data = element;
        }


    }
}

错误在removeFirst()。

有什么帮助吗？

编辑： 我正在尝试存储最后一个引用的节点，以便我可以在其他地方使用它。

Answer 1

通常该错误意味着无限递归。我建议你看看下面的代码部分。

 while(it.hasNext()){
            temp.append(it.next());
            if(it.hasNext())
                temp.append(", ");
        }

Answer 2

您的代码相当臃肿。看看这个：

How do I create a Linked List Data Structure in Java?

如果您不想要额外的分数，请尝试添加泛型：

http://docs.oracle.com/javase/tutorial/java/generics/