数据结构之循环链表以及约瑟夫问题

循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可。

循环链表的实现

public class CirculationLinkList {
    static class Node<T> {
        T item;
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    public static void main(String[] args) {
        Node<String> one = new Node<>("a", null);
        Node<String> two = new Node<>("b", null);
        Node<String> three = new Node<>("c", null);
        Node<String> four = new Node<>("d", null);
        Node<String> five = new Node<>("e", null);
        Node<String> six = new Node<>("f", null);
        Node<String> seven = new Node<>("g", null);
        one.next = two;
        two.next = three;
        three.next = four;
        four.next = five;
        five.next = six;
        six.next = seven;
        seven.next = one;
        
    }
}

约瑟夫问题？？？？？？
问题描述：
传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往
后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与
第31个位置，从而逃过了这场死亡游戏 。
问题转换：
41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。
1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；
2.自退出那个人开始的下一个人再次从1开始报数，以此类推；
3.求出最后退出的那个人的编号

解题思路：
1.构建含有41个结点的单向循环链表，分别存储1~41的值，分别代表这41个人；
2.使用计数器count，记录当前报数的值；
3.遍历链表，每循环一次，count++；
4.判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0；
1，循环生成41个节点

public class CirculationLinkList {
    //节点类
    static class Node<T> {
        T item;
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    //解决约瑟夫问题
    public static void main(String[] args) {
        Node<Integer> first = null;
        Node<Integer> curr = null;
        for (int i = 1; i <= 41; i++) {
            //初始化首节点，以及记录当前节点
            if (i == 1) {
                first = new Node<>(i, null);
                curr = first;
                continue;
            }
            //循环生成下一个节点
            Node<Integer> newnode = new Node<>(i, null);
            curr.next = newnode;
            curr = newnode;
            //最后一个节点指向第一个节点
            if (i == 41) {
                curr.next = first;
            }
        }
        for (int i = 1; i <= 41; i++) {
            System.out.println(first.item);
            first = first.next;
        }
    }
}

完整代码：

public class CirculationLinkList {
    //节点类
    static class Node<T> {
        T item;
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    //解决约瑟夫问题
    public static void main(String[] args) {
        Node<Integer> first = null;
        Node<Integer> curr = null;
        for (int i = 1; i <= 41; i++) {
            //初始化首节点，以及记录当前节点
            if (i == 1) {
                first = new Node<>(i, null);
                curr = first;
                continue;
            }
            //循环生成下一个节点
            Node<Integer> newnode = new Node<>(i, null);
            curr.next = newnode;
            curr = newnode;
            //最后一个节点指向第一个节点
            if (i == 41) {
                curr.next = first;
            }
        }
        //模拟计数器
        int count = 0;
        //遍历链表
        //节点从第一个开始
        Node<Integer> n = first;
        //记录n的上一个节点，因为当前节点要是为3，删除当前节点要用到前一个节点
        Node<Integer> pre = null;
        //当n=n.next说明还剩一个，所以n！=n.next的时候就得循环删除
        while (n != n.next) {
            count++;
            //如果是3，删除，并打印
            if (count == 3) {
                pre.next = n.next;
                System.out.println(n.item);
                count = 0;
                n = n.next;

            }
            //如果不是3，让当前节点变为pre,当前节点后移
            else {
                pre = n;
                n = n.next;

            }

        }
        System.out.println(n.item);

    }
}

还特么挺好玩！！！！