A linked list is a data structure in which each individual piece of data, which are called links or nodes, keeps track of the other elements in the list. The advantage of this design is that elements can be added or removed at any point very easily. Whereas in an indexed array, all succeeding elements have to be shifted when an element is added or removed, in a linked list, only a few pointers have to modified when performing such operations. The downside of that we lose all forms of indexing. Below is an example of a Node class designed for a singly-linked list, or one in which each node keeps track of the next link only: /** * A simple node implementation for a singly-linked list. * * @param The type of element to store in this Node. */ class Node { /** Stores the data for this Node */ E item; /** Stores the next Node in the structure. */ Node nextLink; /** * Constructs a new Node with the given arguments. * * @param element The data for this Node. * @param next The next link in the list. */ Node(E element, Node next) { item = element; nextLink = next; } } Before introducing a doubly-linked structure, let's take a look at a simple, singly-linked list implementation: /** * A simple singly-linked list. * * @param The type of element to store in this LinkedList. */ class LinkedList { /** Points to the first link in the structure. */ Node firstLink; /** Points to the last link in the structure. */ Node lastLink; /** Stores the size of this list */ int size; /** Constructs a new, empty LinkedList. */ public LinkedList() { } // Other methods not shown. } Because each individual link in the structure stores a reference to the next element, our data structure class needs only to keep track of where the list begins and where it ends. Generally, the last link stores a null reference as its next link, i.e. lastLink.nextLink == null. Additionally, we should make size an instance variable in LinkedList so that any objects of we create will have an independent amount of elements. If your instructor allows it, you might want to extend the AbstractSequentialList class with your LinkedList if you need help with what methods you should have. To quickly recap, in a singly-linked list, each node, as in the imposed Node class above, stores a reference to the next element. Such a structure can only be traversed forwards, a limitation which is oftentimes an issue. To remedy this, we can make each node keep track of the previous node as well as the next node, creating what's called a doubly-linked list: /** * A simple node implementation for a doubly-linked list. * * @param The type of element to store in this Node. */ class Node { /** Stores the previous Node in the structure. */ Node previousLink; /** Stores the data for this Node */ E item; /** Stores the next Node in the structure. */ Node nextLink; /** * Constructs a new Node with the given arguments. * * @param previous The previous link in the list. * @param element The data for this Node. * @param next The next link in the list. */ Node(Node previous, E element, Node next) { previousLink = previous; item = element; nextLink = next; } } This is essentially all that needs to change to "upgrade" our LinkedList to a doubly-linked structure, which can be traversed both backwards and forwards. In general, the first node should store a null reference as its previous link, and the last link should store a null reference as its next link. If you haven't worked with Iterators before, take a look at the Iterator and ListIterator Javadocs. An Iterator is usually placed inside the class of a particular data structure and provides for a means of traversal. In the case of our doubly-linked list, we'll need to create two Iterators, one that traverses forwards and one that traverses backwards. I'll leave the implementation up to you, but the simplest way to do this is as follows: /** List Iterator with elements in the proper sequence. */ private class LLIterator implements ListIterator { private Node lastReturned = null; private Node next; private int nextIndex @Override public int previousIndex() { // TODO } @Override public int nextIndex() { // TODO } @Override public boolean hasPrevious() { // TODO } @Override public E previous() { // TODO } @Override public boolean hasNext() { // TODO } @Override public E next() { // TODO } @Override public void remove() { // TODO (optional) } @Override public void add(E e) { // TODO (optional) } @Override public void set(E e) { // TODO (optional) } } /** List Iterator with elements in descending sequence. */ private class DescendingIterator implements Iterator { private final LLIterator iterator = new LLIterator(); @Override public boolean hasNext() { return iterator.hasPrevious(); } @Override public E next() { return iterator.previous(); } @Override public boolean remove() { return iterator.remove(); } } More on reddit.com

If it's empty you can just check if head is null otherwise you're trying to access something inside of null, which doesn't exist.

And what do you mean head.next is your first element? Head shouod be your first element. And tail should be your last element. Heads previous node shouod be null, and the tail elements next value should be null. Seems like you're doing it a little weird. So let's look at a simple change of head as an example. Say you have 3 elements you can assign you can create a new node, point itd next value at the current head, then change head to the new node. Tail is just reverse.

So if your list is empty (head is null) to append all you need to do is

 head = new Node(data);

next and prev should already be null upon creation

More on reddit.com

Jesus mate. You don't need to question your ambitions just because you're stuck on an assignment your peers seem to pass. Ask for some damn help. Learning by yourself can only get you so far. If I'm stuck, I re-read the assignment, make sure to create a solid foundation and solve exactly as stated in the assignment. Last resort you can try reading and understanding what the junit tests do. Most of all, get some damn sleep More on reddit.com

Following questions would help. Did you study Comp Organization, Architecture ? A machine memory model? Those are necessary to understand the physical reality of LinkedList. Essentially memory and Pointers. This book here talks about Linked List in absolute details. https://theswissbay.ch/pdf/Gentoomen%20Library/Algorithms/Algorithms%20in%20C.pdf#page=32 The 2nd OG book. The first OG book would be Knuth, and here it is describing LinkedList. www.haio.ir/app/uploads/2022/01/The-Art-of-Computer-Programming-Vol.-1-Fundamental-Algorithms-3rd-Edition-by-Donald-E.-Knuth-z-lib.org_.pdf#page=254 Incidentally Sidgewick got his PHD from Donald Knuth. More on reddit.com