CS 216
Data Structures and Algorithms

Spring 2026

---

Preliminaries

Download the new DrJava from Moodle (verison 01/20/26).

This version as "Javadoc" and "JUnit" buttons:

• To build, i.e. check for erros, use Run button as before. Do not worry if you see:

  Note: src/cs1/DLinkedList/DLinkedListTest.java uses unchecked or unsafe operations.
  Note: Recompile with -Xlint:unchecked for details.
  launching DLinkedList...
  Error: Main method not found in class DLinkedList, please define the main method as:
     public static void main(String[] args)
  or a JavaFX application class must extend javafx.application.Application
  

• To run the code use JUnit button. This button actually runs the code and colors in each line.

Preliminaries

Here is the minimum expectation for Monday for classes DLinkedList and DLinkedListTest (separately prepare and submit coverage and api documents, coverage.pdf and api.pdf):

• class DLinkedList:
  • must contain all methods mentioned below
  • the methods do not need to be correct -- it is enough to only have return; OR return false; OR return null; as appropriate so that the code compiles without errors; here is a sample SLinkedList.java (Monday)
  • the methods must compile without error (see above), but are not required to be correct
  • each method must have complete Javadoc style comment (in your own words) including @param, @return, @throws where appropriate (see the class examples below)

• class DLinkedListTest:
  • contains test cases for all methods using the JUnit framework
  • each method is tested on an empty, single, and multi list
  • each individual test has one of these forms:

    boolean methods	non-boolean methods
    list = load( the-list-values ); assertTrue( list.methodToTest() ); assertEquals( list.toStringNext(), "[the expected values]" ); assertEquals( list.toStringPrev(), "[same values as above]" );	list = load( the-list-values ); assertTrue( list.methodToTest().equals( some-value ) ); assertEquals( list.toStringNext(), "[the expected values]" ); assertEquals( list.toStringPrev(), "[same values as above]" );
    void methods	exception expected
    list = load( the-list-values ); list.methodToTest(); assertEquals( list.toStringNext(), "[the expected values]" ); assertEquals( list.toStringPrev(), "[same values as above]" );	list = load( the-list-values ); assertThrowsExactly( ExpectedException.class, () -> list.methodToTest() ); assertEquals( list.toStringNext(), "[the expected values]" ); assertEquals( list.toStringPrev(), "[same values as above]" );

  • some methods will require multiple test cases per list configuration (for example get(..), set(..), contains(..))
  • SLinkedListTest.java has examples on how to test boolean methods (see test_isEmpty); void methods (see test_addLast); and methods that return an object or throw exception (see getFirst)

Handouts

In class we implemented several methods of a (non-header) singly-linked list, i.e. each node had a pointer only to its successor node:

Here is a collection of videos that demonstrate how a method is executed and how the code can be debugged:

Description (Part I)

For this assignment you are asked to implement a Header Doubly-Linked List with a header node:

• Header Node means that the head arrow always points to a secret node called a dummy node; it is created with null for data
• Doubly-Linked means that each node has two links: a link to the next node (the successor) and a link to the previous (the predecessor)

The dummy node is a special node that you put as the programmer to make things easier for you. The user does not know about the existence of the dummy node. The data of the dummy node is null and the head always points to the dummy node.

Here is an illustration of the representation with and without a dummy node. We chose to implement the version without dummy node:

empty list	head-->▮ head-->null|*-->▮
one element	head--> 5 |*-->▮ head-->null|*--> 5 |*-->▮
multi element	head--> 8 |*--> 5 |*--> 4 |*--> 7 |*-->▮ head-->null|*--> 8 |*--> 5 |*--> 4 |*--> 7 |*-->▮

Description (Part II)

Create a class DLinkedList (in a project also called DLinkedList in your cs216 folder) such that:

• each node has a pointer to its successor and predecessor

• the DLinkedList has pointers (i.e. has data members) to both the head of the list (the dummy node) and the tail of the list (the last node); initially both the head and the tail point to the dummy node

• the DLinkedList does not keep track of its current size

• the DLinkedList methods throw exceptions where appropriate (either NoSuchElementException or IndexOutOfBoundsException, only one type of exception per method)

• the DLinkedList methods are documented using the Javadoc style (see the methods getFirst and addFirst in SLinkedList.java)

• the DLinkedList methods are organized and tested rigorously using the JUnit framework as shown in SLinkedListTest.java

The DLinkedList should support the following methods of the List interface:

Do not write additional methods that are not specified in the assignment and do not call any of the DLinkedList methods from within any other method (it is fine to call isEmpty but do not overuse it).

default constructor Creates an empty list.

boolean isEmpty() Determines if the list is empty.

void addFirst(E item) Adds the given item to the front of the list.

void addLast(E item) Adds the given item to the end of the list.

E getFirst() Returns the first element in the list.

E getLast() Returns the last element in the list.

boolean contains(E item) Determines if the list contains the given item.

E get(int index) Returns the item at the given index in the list.

E set(int index, E item) Replaces the item in the node at the given index with the given item returns the previous item at that index.

void add(int index, E item) Adds the given item at the given index in the list. In other words, after this operation, the given item will be in position index in the list, so if the list currently has 5 elements, add(0, ...) has the effect of adding to the beginning and add(5, ....) has the effect of adding to the end; indices outside the range [0..5] are invalid. Note that the dummy node is not counted, since it does not exist from the user's point of view. Do not use methods addFirst and addLast.

void clear() Clears all the elements in the list. (Go through the list and set the two links of each node to null.)

String toStringNext() Returns a string representation of the list in this format: [] (for empty list), [1 2 3 4] (for non-empty list).

String toStringPrev() Returns a string representation of the list (as in toStringNext). Important: this method must traverse the list starting from the end by following the back-pointing links this method must returns exactly the same string as method toStringNext; i.e. even though we walk backwards the final string still has the items in front-to-back order (hint: s=s+thing vs s=thing+s) there should be no .next anywhere in this method In the JUnit tester you must use assertEquals with both toStringNext and toStringPrev -- this will help to ensure that the forward and back links are connected correctly.

What to turn in

Upload the .java, .log, and .pdf files in the Moodle dropbox. (Do NOT upload .html files.)