环形链表实现类

package day03;

/**
 * @Author yqq
 * @Date 2022/05/05 11:41
 * @Version 1.0
 * 模拟环形单链表的实现
 */
public class CycleLinkedList {
    /**
     * 用于保存单链表中的首节点
     */
    private Node headNode;
    /**
     * 用于保存单链表中的尾结点
     */
    private Node lastNode;
    /**
     * 用于保存单链表中节点的个数
     */
    private  int size;

    public CycleLinkedList() {
    }
    public CycleLinkedList(int size) {
        this.size = size;
    }
    public int size(){
        return this.size;
    }

    /**
     * 在链表尾部添加元素
     * @param element
     */
    public void add(Object element){
        //把需要添加的数据封装成对象
        Node node = new Node(element);
        //处理单链表为空的情况
        if (headNode == null){
            //把node节点设置成单链表的首节点
            headNode = node;
            //把node设置成单链表的尾结点
            lastNode = node;
        }else {//处理单链表不为空的情况
            //让lastNode指向node节点
            lastNode.next = node;
            //更新lastNode的值
            lastNode = node;
        }
        //设置lastNode的next为headNode
        lastNode.next = headNode;
        //更新size的值
        size ++;
    }
    /**
     * 根据序号获取元素的值
     */
    public Object get(int index){
        //判断序号是否合法
        if (index < 0)
            throw new IndexOutOfBoundsException("序号不合法，index:"+ index);
        //根据序号获取对应的节点对象
        Node node = node(index);
        //获取并返回node节点的数据值
        return node.data;
    }

    /**
     * 根据序号删除元素
     * @param index
     */
    public void remove(int index){
        //判断序号是否合法
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("序号不合法，index:"+ index);
        //处理删除节点在开头的情况
        if (index == 0){
            //获得删除节点的后一个节点
            Node nextNode = headNode.next;
            //设置headNode的next值为null
            headNode.next = null;
            //设置设置nextNode为单链表的首节点
            headNode = nextNode;
            //设置lastNode的next为headNode
            lastNode.next = headNode;
        }
        //处理删除节点在结尾的情况
        else if (index == size - 1){
            //获得删除节点的前一个节点
            Node preNode = node(index - 1);
            //设置preNode的next为null
            preNode.next = null;
            //设置preNode为单链表的尾结点
            lastNode = preNode;
            //将lastNode的next设置为headNode
            lastNode.next = headNode;
        }
        //删除节点在中间的情况
        else {
            //获得index-1所对应的节点对象
            Node preNode = node(index - 1);
            //获得index+1所对应的节点对象
            Node nexNode = preNode.next.next;
            //获得删除节点，并设值为null
            preNode.next.next = null;
            //设置preNode的next值为nexNode
            preNode.next = nexNode;
        }
        //更新size的值
        size --;
        //判断size的值是否为0，如果size的值为0，则设置headNode和lastNode为null,此处代码必须在 size--之后
        if (size == 0){
            headNode = null;
            lastNode = null;
        }
    }

    /**
     * 根据序号插入元素
     * @param index
     * @param element
     */
    public void add(int index, Object element){
        //判断序号是否合法
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("序号不合法，index:" + index);
        //把需要添加的数据封装对象
        Node node = new Node(element);
        //处理插入节点在开头的情况
        if (index == 0){
            //设置node节点的next为headNode
            node.next = headNode;
            //设置node为单链表的首节点
            headNode = node;
            //设置lastNode的next为headNode
            lastNode.next = headNode;
        }
        //处理插入节点在末尾的情况
        else if (index == size - 1){
            //设置lastNode的next为node
            lastNode.next = node;
            //设置node为单链表尾结点
            lastNode = node;
            //设置lastNode的next指向headNode
            lastNode.next = headNode;
        }
        //处理插入节点在中间的情况
        else {
            //获得index-1所对应的的节点对象
            Node preNode = node(index - 1);
            //获得index所对应的节点对象
            Node curNode = preNode.next;
            //设置preNode的next为node
            preNode.next = node;
            //设置node的next为curNode
            node.next = curNode;
        }
        //更新size的值
        size ++;
    }
    /**
     * 根据序号获取对应节点对象
     * @param index
     * @return
     */
    private Node node(int index){
        //如果环形链表为空
        if (headNode == null)
            throw new NullPointerException("环形单链表为空表");
        //定义一个临时节点
        Node tempNode = headNode;
        //定义一个循环，用于获取index对应的节点对象
        for (int i = 0; i < index % size; i++) {
            //更新tempNode的值
            tempNode = tempNode.next;
        }
        return tempNode;
    }
    /**
     * 节点类
     */
    private static class Node{
        /**
         * 用于保存节点中的数据
         */
        private Object data;
        /**
         * 用于保存指向下一个节点的地址值
         */
        private Node next;

        /**
         * 构造方法
         * @param data
         */
        public Node(Object data) {
            this.data = data;
        }
    }
}

测试类

package day03;

/**
 * @Author yqq
 * @Date 2022/05/06 12:24
 * @Version 1.0
 */
public class Test04 {
    public static void main(String[] args) {
        CycleLinkedList list = new CycleLinkedList();
        list.add("11");
        list.add("22");
        list.add("33");
//        list.add("44");
        //根据序号获取元素
        //根据序号删除元素
//        list.remove(0);
        //根据序号位置插入元素
        list.add(3,"0");
//        System.out.println(list.get(5));
        System.out.println();
    }
}