public/subjects/java/checkpoints/circular-linkedlist/README.md

## Circular Linked List

### Instructions

Create a circular single linked list data structure that implements the following methods:

- `at(int index)`: to access an element by its index. if the index is negative or if the list is empty return -1.
- `add(int value)`: to add an element at the end of the list.
- `remove(int index)`: to remove an element by its index.
- `size()`: to return the size of the list.

Define these methods in an interface called `LinkedList`, and implement this interface in a class called `CircularLinkedList`. Additionally, add a private method `next(Node node)` in this class to use it for travers the list in other methods. This method should print the message "Go to next node\n" each time it is called.

If the index is over the size then you have to keep going using `next` method to achieve the given index.

### Explanation

A circular linked list is a linear data structure where each element is a separate object called a node. Each node contains two fields:

- `value`: stores the data.
- `next`: stores a reference to the next node in the list.

The first node is called the head of the list and the last node in a circular linked list points back to the first node, forming a circle. The list allows for efficient insertion and deletion of elements. However, accessing an element by its index requires traversing the list from the head to the desired position.

### Expected Interface

````java
public interface LinkedList {
    int at(int index);
    void add(int value);
    void remove(int index);
    int size();
}

### Expected Class

```java
public class CircularLinkedList implements LinkedList {
    private Node head;

    private class Node {
        int value;
        Node next;

        Node(int value) {
            this.value = value;
            this.next = null;
        }
    }

    @Override
    public int at(int index) {
        // Implementation for accessing an element by its index
    }

    @Override
    public void add(int value) {
        // Implementation for adding an element at the end of the list
    }

    @Override
    public void remove(int index) {
        // Implementation for removing an element by its index
    }

    @Override
    public int size() {
        // Implementation getting the size of the list
    }

    private Node next(Node node) {
        // Print the message "Go to next node"
    }
}
````

### Usage

Here is a possible `ExerciseRunner.java` to test your class:

```java
public class ExerciseRunner {
    public static void main(String[] args) {
        LinkedList list = new CircularLinkedList();

        // Add elements to the list
        list.add(1);
        list.add(2);
        list.add(3);

        // Access elements by index
        System.out.println("Element at index 0: " + list.at(0)); // Expected output: 1
        System.out.println("Element at index 1: " + list.at(1)); // Expected output: 2
        System.out.println("Element at index 2: " + list.at(2)); // Expected output: 3

        // Remove an element by index
        list.remove(1);
        System.out.println("Element at index 1 after removal: " + list.at(1)); // Expected output: 3
    }
}
```

### Expected Output

```shell
$ javac *.java -d build
$ java -cp build ExerciseRunner
Go to next node
Element at index 0: 1
Go to next node
Element at index 1: 2
Go to next node
Go to next node
Element at index 2: 3
Go to next node
Go to next node
Element at index 1 after removal: 3
$
```