Thread: LinkedList -- insert()

Hard to say what the problem is without code that can be compiled and executed for testing.

main

public class MainClass {
 
	public static void main(String[] args) throws PointerOutOfBoundsException {
 
	//	StringX star = new StringX("Betelgeuse");
	//	System.out.println(star.toString());
 
		MySinglyLinkedList<String> myStringList = new MySinglyLinkedList<String>();
		myStringList.addToFront("Orion");
		System.out.println(myStringList.getNext());
	}
}

public interface SinglyLinkedList<T> {
 
	public void traverse();
 
	public void addToFront(T newMember);
 
	public void addToRear(T newMember);
 
	//public Node search(T key);
 
	public void insert(T newMember, int index) throws IndexOutOfBoundsException;
 
	//public boolean delete(T key);
}

public class MySinglyLinkedList<T> implements SinglyLinkedList<T> {
	protected Node<T> head, tail, current;
	int size = 0;
 
	// /The node accessor method returns a reference to the node, this can be
	// avoided by making the Node a private inner class.
	private class Node<T> {
 
		protected T element; // contents within node
		private Node<T> link; //node pointer
 
		public Node() {
			element = null;
			link = null;
		}
 
		public Node(T element) {
			this.element = element;
		}
 
		public void setLink(Node<T> link) {
			this.link = link;
		}
 
		public Node<T> getLink() {
			return link;
		}
 
		public void setElement(T element) {
			this.element = element;
		}
		public T getElement() {
			return element;
		}
 
		public String toString(T element) {
			return (element + " ");
		}
	}
 
	// ///////////////END OF NODE CLASS////////////////////
	public MySinglyLinkedList() {
		head = null;
 
		current = null;
	}
 
	public void traverse() {
		current = new Node<T>();
		reset();
		while (current != null) {
			System.out.println(current.getElement());
			current = current.getLink();
		}
	}
//add node to list - test for existing nodes
	public void addToFront(T newMember) {
		//initialize new node object
		Node<T> firstNode = new Node<T>(newMember);
 
		if (empty()) {
			firstNode.link = head;
			//firstNode.setLink(head);
			firstNode.setElement(newMember);
			firstNode = head;
			current = head;
			System.out.println(newMember);
		} 
		else {
			Node<T> newNode = new Node<T>();
			newNode.link = head;
			head = newNode;
		}
	}
 
	public void addToRear(T newMember) {
		Node<T> lastNode = new Node<T>(newMember);
 
		if (tail == null) {
			head = tail = lastNode;
		} else {
			tail.link = lastNode;
			lastNode = tail;
		}
	}
 
	public void insert(T newMember, int index) throws IndexOutOfBoundsException {
 
	}
 
	/*
	 * public Node search(T key) { reset(); T itemPosition;
	 * 
	 * while(current != null) { itemPosition = current.element;
	 * 
	 * if(itemPosition.equals(key)) { return current; } else return null; }
	 * return current.getNext(); }
	 */
	/*public boolean delete(T key) {
		reset();
		Node<T> tempNode = new Node<T>(key);
 
		if(head == current) {
			head = tempNode.link;
		}	else if(tail == current) {
				tail = previous.link;
			}
 
 
		return false;
	}
*/
	private boolean empty() {
		return (head == null);
	}
 
	public int size() {
		Node<T> newNode = new Node<T>();
		while (head != null) {
			size++;
			tail = newNode.link;
		}
		return size;
	}
 
	public void reset() {
		current = head;
	}
 
	public Node<T> getNext() throws PointerOutOfBoundsException {
 
		if (hasNext()) {
			current = current.getLink();
			return current;
		} else 
			throw new PointerOutOfBoundsException();
 
	}
 
	public boolean hasNext() {
		if (current == null) {
			return false;
		}
		return (current.getLink() != null);
	}
 
}

public class PointerOutOfBoundsException extends Exception {
 
	public PointerOutOfBoundsException() {
		System.out.println("Pointer Out Of Bounds!");
	}
}

The posted code does not compile because of missing class definitions.

*Updated* I forgot to add the exception class.

I've outlined the linkedlist concept on pen and paper, and feel I have a fairly good grasp of it. (I'll be sure to use the "process" you mentioned earlier next time before getting neck deep into a program.)

firstNode.setElement(newMember); should store the contents of the node object and allow the element to be retrieved....is this an unnecessary step?

As far as the pointer exception being thrown...I'm assuming this is because current is retaining its null value within the next methods, instead of the current = head value within addToFirst(). Would that be correct?

The lack of comments makes it hard to understand what the variables are for and what the logic is.
For example: what is the value that is supposed to be in the current variable? Don't bother posting it here. It should be in the code.

A suggestion for debugging:
Add a toString() method to the Node class that returns a String with the value of the element and the value of the link. Also add a toString() method to the MSLL class that returns the value of head, current and tail. Then when the MSLL variable is printed all of the contents will be printed.

I get the error above

You left off the part of the error message that shows where the error is happening. What is the source line?

LinkedList Definition:An ordered set of data elements, each containing a link to its successor (and sometimes its predecessor).
Linked lists are among the simplest and most common data structures. They can be used to implement several other common abstract data types, including lists (the abstract data type), stacks, queues, associative arrays, and S-expressions, though it is not uncommon to implement the other data structures directly without using a list as the basis of implementation.

Types of linked list:1)single linked list.2)double linked list.3)circular linked list.
Example:Node node1 = new Node();
Node node2 = new Node();
LinkedList list = new LinkedList();
list.add(node1);
list.add(node2);

//then my node1 will know who it's next is:
assertEquals(node2, node1.next());
Regards
Srinath.M
(Automation COE) **REMOVED /core-qa-offerings/test-automation