单向环形链表之约瑟夫问题

约瑟夫问题（Josephus problem ）

约瑟夫问题，是一个计算机科学和数学中的问题，在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。

约瑟夫问题是个有名的问题：

N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。
分析：

• 用一个不带头结点的循环链表来处理Josephus 问题，首先构成一个有n个结点的单循环链表。

• 由k结点起从1开始计数，记到m时，对应结点从链表删除。

• 然后从被删除结点的下一个节点又从1开始计数，直到最后一个节点从链表中删除。

单向环形链表（Circular linked）

对于单链表，由于每个节点只存储了向后的指针，到了尾标志就停止了向后链的操作，这样，当中某一个节点无法找打他的前驱结点了，不记得的同学可以去看一眼。
单向链表实现

环形链表就解决了这个问题。怎么做到的呢？将单链表中的终端结点的指针由空指针NULL改为指向头结点，这样就使单链表形成了一个环，这种头尾相接的单链表就是环形链表了。

环形链表解决了一个很麻烦的问题，就是从链表的任意结点出发，能够访问到全部的结点。

单链表和环形的链表其实就一个差别就是在判断循环的条件，原来是当前节点的next为null，而环形链表是当前节点的next不等于头结点。

单向环形链表实现

package LinkList.circular;

/**
 * 单向环形链表
 */
public class CircularLinkListTest {

    public static void main(String[] args) {

        CircularLinkList circularLinkList = new CircularLinkList();
        circularLinkList.add(5);
        circularLinkList.show();

        circularLinkList.out(1,2,5);
    }


}


/**
 * 环形单链表
 */
class  CircularLinkList{

    //创建一个first节点
    private Node first = null;

    /**
     * 添加结点，构建环形链表
     * @param num 结点数量
     */
    public void add(int num){
        if (num < 1){
            throw new RuntimeException("请输入合适值");
        }
        System.out.println("循环单链表全部结点");
        //辅助指点，指向尾结点
        Node cur = null;
        // 循环创建
        for (int i = 1; i <= num; i++) {
            // 根据编号 创建结点
            Node node = new Node(i);
            //考虑只有一个节点。
            if (i == 1){
                first = node;
                first.setNext(first);
                //尾结点指向头结点
                cur = first;
            }else {
                cur.setNext(node);
                node.setNext(first);
                cur = node;
            }
        }
    }

    /**
     * 遍历环形链表
     */
    public void show(){
        if (first == null){
            throw new RuntimeException("环形链表为空");
        }
        //辅助指针，因为头结点不动。
        Node cur = first;
        while (true){
            System.out.println("结点编号：" + cur.getNo());
            //是否遍历完成
            if (cur.getNext() == first){
                break;
            }
            //后移
            cur = cur.getNext();

        }
    }


    /**
     * 结点出链表
     * @param startNo 开始结点
     * @param count 数几次
     * @param num 结点个数
     */
    public void out(int startNo,int count,int num){
        if (first == null || startNo < 1 || startNo > num){
            throw new RuntimeException("请输入合适值");
        }
        //辅助指针
        Node temp = first;
        while (true){
            //循环了最后一个节点
            if (temp.getNext() == first){
                break;
            }
            //指针后移
            temp = temp.getNext();
        }
        //报数前，将first和temp移动k-1次，就是到了startNo位置
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            temp = temp.getNext();
        }
        //报数时，让first和temp同时移动m-1次,直到链表中只有一个节点。
        while (true){
            // 链表中只有一个节点了
            if (temp == first){
                break;
            }
            // 让first和temp指针同时移动count - 1 ，然后出圈
            for (int i = 0; i < count - 1; i++) {
                first = first.getNext();
                temp = temp.getNext();
            }
            //first指向的节点就是要出链表的节点
            System.out.println(first.getNo());
            first =  first.getNext();
            temp.setNext(first);
        }
        System.out.println("留在链表中的编号：" +first.getNo());
    }
}

/**
 * 节点信息
 */
class Node{

    //编号
    private int no;
    //指向下一个节点，默认为null
    private Node next;

    //构造器
    public Node(int no){
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

输出结果