数据结构：约瑟夫问题Java实现

数据结构：约瑟夫问题Java实现

一 序言
约瑟夫问题：N个人围成一圈，从约定编号为K的人开始报数，第M个将被杀掉，依次类推，最后剩下一个，其余人都将被杀掉。

二 思路解析
I) 数组和链表

从第K个节点开始，往后数到M，移除第M个节点，然后从刚才移除节点的下一个节点重新数，当数到an时还没有数到M，此时需要重新从a1节点(如果a1节点还未移除，如果已被移除则往后找其未移除的节点)开始数，…，直到剩下一个节点。
图中an指向a1的虚线表示它们物理存储时不想连

II) 循环链表

从第K个节点开始，往后数到M，移除第M个节点，然后从刚才移除节点的下一个节点重新数，当数到an时还没有数到M，此时需要重新从a1节点(如果a1节点还未移除，如果已被移除则往后找其未移除的节点)开始数，…，直到剩下一个节点。
图中an指向a1的实线表示它们物理存储时想连

三 Java实现
I) 数组实现方式

package com.datastruct.linear;

import org.omg.CORBA.PERSIST_STORE;

/**
 * Description: 【数据结构-约瑟夫问题】数组实现方案
 *
 * @author guodong
 * @date 2020/3/29 15:17
 */
public class JosephArray {

    /**
     * 总人数
     */
    private static final int N = 10;
    /**
     * 设置名称
     */
    private static String[] PEOPLE_NAME = new String[N];
    /**
     * 当前剩下的人数
     */
    private static int PEOPLE_SIZE = N;

    public static void main(String[] args) {
        for (int i = 0; i < N; i++) {
            PEOPLE_NAME[i] = "NAME_" + (i + 1);
        }
        doJoseph(4, 3);
    }

    /**
     * 从第 K 个人开始，数到 M 时则移除节点
     *
     * @param K 首次数数的位置
     * @param M 数数的次数
     * @return void
     */
    private static void doJoseph(int K, int M) {
    	if (K > N) {
            System.out.println("首次数数的人应该小于当前人数");
            return;
        }
        // 数组从0开始，所以需要先减去1
        K = K - 1;
        while (PEOPLE_SIZE != 1) {
            // 从开始数M个，包含K本身，所以要减去1
            K = delete(K + M - 1);
        }
        System.out.println("剩下的人叫：" + PEOPLE_NAME[0]);
    }

    /**
     * 移除指定位置数据，流程
     * 1.判断指定位置的人是否已经出列（是否为null）
     * 2.未出列，则让其出列(设置为null)
     * 3.当前出列人后面的人往前移动
     * 4.重新计算下一个开始数数的人位置
     * 
     * <pre>
     *     对<code>PEOPLE_SIZE</code>取余是为了找到剩下人的相对所有人的位置
     * </pre>
     *
     * @param local 位置
     * @return void
     */
    private static int delete(int local) {
        // 1.判断指定位置的人是否已经出列
        String tmp = PEOPLE_NAME[local % PEOPLE_SIZE];
        // 2.未出列，则让其出列
        if (tmp != null) {
            System.out.println("本次出列的人叫：" + tmp);
            tmp = null;
        }
        // 3.当前出列人后面的人往前移动
        for (int i = local % PEOPLE_SIZE; i < PEOPLE_SIZE - 1; i++) {
            PEOPLE_NAME[i] = PEOPLE_NAME[i + 1];
        }
        // 4.重新计算下一个开始数数的人位置
        int next = local % PEOPLE_SIZE;
        PEOPLE_SIZE--;
        return next;
    }
}

结果

本次出列的人叫：NAME_6
本次出列的人叫：NAME_9
本次出列的人叫：NAME_2
本次出列的人叫：NAME_5
本次出列的人叫：NAME_10
本次出列的人叫：NAME_4
本次出列的人叫：NAME_1
本次出列的人叫：NAME_8
本次出列的人叫：NAME_3
剩下的人叫：NAME_7

II) 单链表实现方式

package com.datastruct.linear;

/**
 * Description: 【数据结构-约瑟夫问题】链表实现方案
 *
 * @author guodong
 * @date 2020/3/29 15:17
 */
public class JosephLinked {

    /**
     * 总人数
     */
    private static final int N = 10;
    /**
     * 第一个人
     */
    private static JosepphNode root;
    /**
     * 当前剩下的人数
     */
    private static int PEOPLE_SIZE = N;

    public static void main(String[] args) {
        setName();
        doJoseph(4, 3);
    }

    private static void doJoseph(int K, int M) {
    	if (K > N) {
            System.out.println("首次数数的人应该小于当前人数");
            return;
        }
        // 1.找到首次数数的人
        JosepphNode tmp = root;
        for (int i = 0; i < K - 1; i++) {
            tmp = tmp.getNext();
        }
        while (PEOPLE_SIZE != 1) {
            // 2.开始数M，第M个人退出
            for (int i = 0; i < M - 2; i++) {
                if (tmp.getNext() == null) {
                    tmp = root;
                } else {
                    tmp = tmp.getNext();
                }
            }
            if (tmp.getNext() == null) {
                PEOPLE_SIZE--;
                System.out.println("出列的人叫：" + root.getName());
                root = root.getNext();
                tmp = root;
            } else {
                PEOPLE_SIZE--;
                System.out.println("出列的人叫：" + tmp.getNext().getName());
                if (tmp.getNext().getNext() == null) {
                    tmp.setNext(root);
                } else {
                    tmp.setNext(tmp.getNext().getNext());
                }
                tmp = tmp.getNext();
            }
        }
        System.out.println("剩下的人叫：" + tmp.getName());
    }

    /**
     * 创建N个人
     */
    private static void setName() {
        root = new JosepphNode();
        root.setName("NAME_1");
        JosepphNode tmpNode = root;
        for (int i = 2; i <= N; i++) {
            JosepphNode tmp = new JosepphNode();
            tmp.setName("NAME_" + i);
            tmpNode.setNext(tmp);
            tmpNode = tmp;
        }
    }

}

class JosepphNode {
    private String name;
    private JosepphNode next;

    public JosepphNode getNext() {
        return next;
    }

    public String getName() {
        return name;
    }

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

    public void setName(String name) {
        this.name = name;
    }
}

结果

出列的人叫：NAME_6
出列的人叫：NAME_9
出列的人叫：NAME_2
出列的人叫：NAME_5
出列的人叫：NAME_10
出列的人叫：NAME_4
出列的人叫：NAME_1
出列的人叫：NAME_8
出列的人叫：NAME_3
剩下的人叫：NAME_7

II) 循环链表实现方式