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

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

Why does your loop wait for current to be null? If you insert at the front of the list, you're done. There's no reason to follow the linked list to the end. Essentially you want to go one past the node. Let's say you're linked list consists of 2, 3, 15 (assuming it's sorted). You want to insert 10. So you search for the first number bigger than 10. 2 is not bigger than 10, so move current to 3. 3 is not bigger than 10, so move current to 15. 15 is bigger than 10, so you want to put your new node between 15 and its predecessor. So newNode's next will be the 15 node. newNode's previous will be 15's previous (3). newNode's previous's next will be newNode, and newNode's next's previous will be newNode. You need special cases when the current's next is null, If you try to insert 20, then you will not run into a value bigger than 20. So, it goes after 15. 20's next is null, 20's prev is 15, and 15's next is 20. More on reddit.com