数据结构与算法-单向环形链表（约瑟夫问题）

package linkedlist;

/**
 * @author taoke
 * @desc 单项环形列表（约瑟夫问题）
 * @email 1504806660@qq.com
 * @date 2021/12/29
 */
public class SingleCircleLinkedListDemo {

    public static void main(String[] args) {

        SingleCirceLinkedList singleCirceLinkedList = new SingleCirceLinkedList();
        singleCirceLinkedList.add(5);
        singleCirceLinkedList.show();
        singleCirceLinkedList.count(1, 2);
    }

    static class SingleCirceLinkedList {

        /**
         * 第一个节点
         */
        public Node first;

        /**
         * 添加节点
         * 1、定义第一个节点不能移动
         * 2、当只有一个节点的时候，第一个节点的下一个节点就是第一个节点
         * 3、多个节点的时候，将当前节点的下一个节点指向新的节点
         * 4、新的节点重新指向第一个节点
         *
         * @param size 链表大小
         */
        public void add(int size) {
            if (size < 1) {
                System.out.println("输入的数量不合法");
                return;
            }
            Node temp = null;
            for (int i = 1; i <= size; i++) {
                //依次创建出新的节点
                Node node = new Node(i);
                if (i == 1) {//第一个节点不能移动
                    first = node;
                    //第一个节点产生环形节点
                    first.next = first;
                    temp = first;
                } else {
                    temp.next = node;
                    node.next = first;
                    temp = temp.next;
                }

            }
        }

        /**
         * 打印环形节点
         */
        public void show() {
            if (first == null) {
                System.out.println("链表为空");
                return;
            }
            Node temp = first;
            while (true) {
                System.out.println(temp);
                if (temp.next == first) {
                    break;
                }
                temp = temp.next;
            }
        }

        /**
         * 计算循环队列的有效数量
         *
         * @return 队列有效大小
         */
        public int size() {
            Node temp = first;
            if (temp == null) {
                return 0;
            }
            int length = 1;
            while (temp.next != first) {
                temp = temp.next;
                length++;
            }
            return length;
        }

        /**
         * 打印出队列信息
         *
         * @param start 出队列的起始位置
         * @param num   每次走多少步
         */
        public void count(int start, int num) {
            int size = size();
            if (first == null || size < 1) {
                System.out.println("队列为空");
                return;
            }
            if (start < 0 || start > size) {
                System.out.println("输入参数有误");
                return;
            }
            //定义一个辅助指针
            Node temp = first;
            //将temp的位置移到start起始位置的前一个位置
            for (int i = first.number; i < (start == 1 ? size : start); i++) {
                temp = temp.next;
            }
            while (true) {
                //队列只有一个元素时结束
                if (temp.next == temp) {
                    System.out.println("最后出队列节点的是" + temp);
                    break;
                }
                //每次遍历num-1次
                for (int i = 0; i < num - 1; i++) {
                    temp = temp.next;
                }
                System.out.println("出队列节点是" + temp.next);
                //删除节点
                temp.next = temp.next.next;
            }

        }

    }

    /**
     * 节点
     */
    static class Node {
        /**
         * 编号/排名
         */
        public int number;
        /**
         * 下一个节点
         */
        public Node next;

        public Node(int number) {
            this.number = number;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "number=" + number + '}';
        }
    }


}