The implementation includes methods for adding, removing and iterating through the circular list. From these methods, the remove( Object ) method required more testing.
class Node { Object data; Node next; public Node( Object data ) { this.data = data; } public Node( Object data, Node next ) { this.data = data; this.next = next; } } public class CircularLinkedList { Node entryNode; /** * Adds a node to the circular linked-list via the entry node. */ public void add( Object data ) { if( entryNode == null ) { // Initialize the entry node. // entryNode = new Node( data ); // cant be null bec. self loop has to assigned. // Link entry node to self, as there is only one node on the list. entryNode.next = entryNode; // note apply it as it is circular. /// Note- dont do this. we use this for forward traversal. /// entryNode = entryNode.next; } else { // Add the node to the circular linked-list. entryNode.next = new Node( data, entryNode.next ); } } /** * Removes the first occurrence of the node (as specified by the data). */ public void remove( Object data ) { if( entryNode != null ) { Node itr = entryNode; do { if( itr.next.data.equals( data ) ) { //current head(data) in loop equals or data(we gave ) then remove it if( itr.next == entryNode && entryNode != entryNode.next ) { // There are still nodes left in the list, but the node // that we need to remove is the entryNode(first node); so we need // to reassign the field to the next node in line. itr.next = itr.next.next; entryNode = entryNode.next; } else if( itr.next == itr.next.next ) { // This condition will only be true if there is only one // node left in the list, which will be the entryNode. // entryNode = null; } else { // The node that we need to remove is a regular node, // i.e. not an entryNode. // itr.next = itr.next.next; } // Done! // return; } // Move to the next available node in the list. // itr = itr.next; } while( itr != entryNode ); } } /** * Returns the first occurrence of the node that matches the specified * data or null if not found. Has a O(n) run-time complexity. */ public Node get( Object data ) { if( entryNode != null ) { Node itr = entryNode; do { if( itr.data.equals( data ) ) { return itr; } itr = itr.next; } while( itr != entryNode ); } return null; } /** * Does a full iteration starting and ending at the entry node. */ public void iterate( ) { if( entryNode != null ) { Node itr = entryNode; do { System.out.print( itr.data + " " ); itr = itr.next; } while( itr != entryNode ); // as circular so 1=last means complete traversals System.out.println( ); // just for next line.. } } /** * Test Method */ public static void main( String[ ] args ) { // Initialize and populate the circular linked-list // CircularLinkedList list = new CircularLinkedList( ); for( int i = 1; i <= 5; i++ ) { list.add( i ); } // Prints: 5 4 3 2 1 // list.iterate( ); // Remove nodes 3, 2, 1 from the circular list. // for( int i = 1; i <= 3; i++ ) { list.remove( list.get( i ).data ); } // Prints: 5 4 // list.iterate( ); // Get and remove node 4 // Node node4 = list.get( 4 ); list.remove( node4.data ); // it can also be done through list.remove(4); // Prints: 5 // list.iterate( ); Node node5 = list.get( 5 ); list.remove( node5.data ); list.iterate( ); } }