单向环形链表解决约瑟夫问题

约瑟夫问题：

设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，

数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

单向环形链表图示：

 代码：

import lombok.Data;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;

public class JosephusRingTest {
    @Test
    public void test() {
        RingSingleNode node1 = new RingSingleNode("小一");
        RingSingleNode node2 = new RingSingleNode("小二");
        RingSingleNode node3 = new RingSingleNode("小三");
        RingSingleNode node4 = new RingSingleNode("小四");
        RingSingleNode node5 = new RingSingleNode("小五");
        RingSingleLinkedList ringSingleLinkedList = new RingSingleLinkedList();
        ringSingleLinkedList.addNode(node1);
        ringSingleLinkedList.addNode(node2);
        ringSingleLinkedList.addNode(node3);
        ringSingleLinkedList.addNode(node4);
        ringSingleLinkedList.addNode(node5);
        System.out.println("最初链表~~~~~共" + ringSingleLinkedList.size() + "个");
        ringSingleLinkedList.show();

        List<RingSingleNode> result = ringSingleLinkedList.JosephusRing(1, 2);
        System.out.println(result);
        System.out.println("最终链表~~~~~共" + ringSingleLinkedList.size() + "个");
        ringSingleLinkedList.show();
    }
}

@Data
class RingSingleNode {

    /**
     * 名称
     */
    private String name;

    private RingSingleNode next;

    public RingSingleNode() {

    }

    public RingSingleNode(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "RingSingleNode{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 单向环形链表
 */
class RingSingleLinkedList {
    /**
     * 链表的头部节点
     */
    private RingSingleNode first;

    /**
     * 链表的尾部节点
     */
    private RingSingleNode last;

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return first == null;
    }

    /**
     * 添加节点
     * @param newNode
     * @return
     */
    public boolean addNode(RingSingleNode newNode) {
        if (isEmpty()) {
            //添加第一个节点
            first = newNode;
            newNode.setNext(newNode);
            last = newNode;
            return true;
        }
        newNode.setNext(first);
        last.setNext(newNode);
        last = newNode;
        return true;
    }

    /**
     * 获取链表的长度
     * @return
     */
    public int size() {
        int count = 0;
        if (isEmpty()) {
            return count;
        }

        RingSingleNode temp = first;
        while (temp != last) {
            count++;
            temp = temp.getNext();
        }
        count++;
        return count;
    }

    /**
     * 链表的遍历
     */
    public void show() {
        RingSingleNode temp = first;
        while (temp != last) {
            System.out.println(temp);
            temp = temp.getNext();
        }
        System.out.println(temp);
    }

    /**
     * 约瑟夫环
     * @param k
     * @param m
     * @return
     */
    public List<RingSingleNode> JosephusRing(int k, int m) {
        /*
        设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，
        数到m 的那个人出列，它的下一位又从1开始报数，
        数到m的那个人又出列，依次类推，
        直到所有人出列为止，由此产生一个出队编号的序列。
         */
        List<RingSingleNode> result = new ArrayList<>();
        if (isEmpty()) {
            System.out.println("链表为空，无法成环");
            return result;
        }

        if (k>=1 && k<=size() && m>=1) {
            while (first != last) {
                //first移动（k-1）步到达编号为k的节点,last移动（k-1）步到达新的尾节点
                //报数之后，first和last一起走（m-1）步，first到达需弹出的节点，last则为弹出后的新的尾节点
                //即first,last一起总计走（k + m - 2）步
                for (int i = 0; i < k + m - 2; i++) {
                    first = first.getNext();
                    last = last.getNext();
                }
                //将指定节点弹出链表
                result.add(first);
                first = first.getNext();
                last.setNext(first);
            }
            //链表只剩最后一个节点
            result.add(first);
            first = null;
            last = null;
            return result;
        }
        System.out.println("m或k输入不合法");
        return result;
    }
}