数据结构与算法之Josephus问题(用Java解决)

问题叙述

Josephus问题是下面的游戏：N个人编号从1到N，围坐成一个圆圈。从1号开始传递一个热土豆，。经过M次传递后拿着热土豆的人被清除离座，围坐的圆圈紧缩，由坐在被清除的人后面的人拿起热土豆继续进行游戏。最后剩下的人取胜。因此，如果M=0和N=5，则游戏人依序被清除，5号游戏人获胜。如果M=1和N=5，那么被清除的人的顺序是2，4，1，5，3号人获胜。

首先，围绕问题来看，数据的结构必定是链状的，而且最好是一个环形的链。为了方便实现，直接采用LinkedList类。

实现方法如下：

public static void josephus(LinkedList<Integer> list, int m) {
    int i = 0;
    while (list.size() > 1) {
        for (int j = 0; j < m; j++) {
            i++;
        }
        while (i >= list.size()) {
            i = i - list.size();
        }
        // System.out.println(list.get(i));
        list.remove(i);
    }
    System.out.println("winner is " + list.get(0));
}

这段代码还是很好理解的，当链表中存在一个以上的数据时，就继续执行，如果每传递m次，就移除当前位置的数据。当然也要判断是否超出了链表的边界，如果超出了的话就得重新置 i 于开头。至于为什么是 while (i >= list.size()) 主要是因为无法确定 m 的值，如果m要超出两次边界的话就得减两次size，用while就一定会让i重新置于0开始。

运行时间测试如下(统一定义M为20)：

N	T
1000	1.432 ms
2000	2.831 ms
4000	8.126 ms
8000	22.615 ms
16000	86 ms
32000	329 ms
64000	1.34 s
128000	5.4s

明显的，时间是$O(N^2)$
如果数据量一大，这个时间将会很大。原因在于我们的代码设计部分，我们每次调用remove时，都重新遍历了一遍表，尽管对于LinkedList来说删除效率很高，但是LinkedList的查找效率是很低的，这样一来这个设计就与ArrayList实现的没有区别了。
其实我们遗漏了LinkedList中的迭代器。下面用迭代器来实现这个问题：

public static void betterJosephus(LinkedList<Integer> list, int m) {
    Iterator<Integer> itr = list.iterator();
    int count = 0;
    while (list.size() > 1) {
        if (!itr.hasNext()) {
            itr = list.iterator();
        }
        int temp = -1;
        while (itr.hasNext() && count++ <= m) {
            temp = itr.next();
        }
        if (count > m) {
            count = 0;
            // System.out.println(temp);
            itr.remove();
        }
    }
    System.out.println("winner is " + list.getFirst());
}

其实原理和上面是一致的，主要把越界时的操作和删除元素的操作转移到了迭代器中，通过重新获取迭代器来将迭代器从头开始（模拟环状的链表）。通过迭代器能够有效地利用LinkedList的删除效率高的特性。因为迭代器的时间是$O(1)$，LinkedList的remove时间也是$O(1)$，整体的运行时间理论上是$O(N)$。

时间如下(M统一为20)：

N	T
10000	9ms
100000	49ms
1000000	320ms
10000000	6.4s
20000000	11.6s
30000000	17.3s

在数据量庞大后，时间也明显成为$O(N)$。