约瑟夫环

• Josephus

package ccnu;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo05 {

    public static void main(String[] args) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("c:/users/" + System.getenv("username") + "/desktop/d.txt")));
        int[] nPersons = josephus(7, new int[]{3, 1, 2, 8, 2, 1, 5});
        StringBuffer sb = new StringBuffer();
        for(int del : nPersons){
            sb.append(del + " ");
        }
        byte[] data = sb.toString().trim().getBytes();
        bos.write(data);
        bos.flush();
        bos.close();
    }

    // 约瑟夫环:将n个人按照顺时针围成一圈，从1开始依次报数，当报到3时，这个人退出，再从这个出列的下一个人从1开始重新报数，依次类推，直到所有人出列
    // 其实约瑟夫环问题中当第一个到3的出列后，接下来仍然是到3出列，其实可以按照如下规则：起始在这n个人中随机从一个人开始，他报一个数，从1开始当报到这个数时，出列，这个人再报一个数，依次类推
    public static int[] josephus(int n) {
        if(n <= 0){
            return null;
        }
        int[] delSerials = new int[n];
        int index = 0;
        Node rear = create(n); // 39+1+1=41
        Node p = rear;
        int m = 3;
        while (p.next != p) { // p始终指向下一轮开始报数的前一个人
            for (int i = 1; i < m; i++) { // 得到即将删除节点的前一个节点
                p = p.next;
            }
            delSerials[index] = p.next.data;
            index++;
            p.next = p.next.next;
        }
        delSerials[index] = p.data;
        return delSerials;
    }

    public static int[] josephus(int n, int[] nPersons) {
        if (n <= 0 || nPersons == null || nPersons.length != n) {
            return null;
        }
        int index = 0;
        Node rear = create(n);
        Node p = rear; // p始终指向下一轮开始报数的前一个人
        int m = nPersons[index];
        m = m % n == 0 ? m : m % n; // 这样可以避免多次的不必要遍历
        while (p != p.next) { // 当多于一个节点时
            for (int i = 1; i < m; i++) {
                p = p.next;
            }
            nPersons[index] = p.next.data; // nPersons保存每一个所报的数，当使用完这个数，再将这个人存放在这个位置上
            n--; // 人数减少一个
            m = nPersons[++index]; // 下一轮的报数
            m = m % n == 0 ? m : m % n;
            p.next = p.next.next; // 删除念到指定数的节点，重新连接单循环链表
        }
        nPersons[index] = p.next.data;
        return nPersons;
    }

    public static Node create(int n){
        if(n <= 0){
            return null;
        }
        Node head = new Node(1);
        Node p = head;
        int i = 2;
        while(i <= n){
            Node tmp = new Node(i++);
            p.next = tmp;
            p = tmp;
        }
        p.next = head;
        return p; // 返回尾指针
    }

    private static class Node{
        private int data;
        private Node next;

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