18.n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始， 每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。 当一个数字删除后，从被删除数字的下一个继续删除第m个数字。 求出在这个圆圈中剩下的最后一个数字。

转载请注明出处：http://www.cnblogs.com/wuzetiandaren/p/4263868.html 

声明：现大部分文章为寻找问题时在网上相互转载，此博是为自己做个记录记录，方便自己也方便有类似问题的朋友，本文的思想也许有所借鉴，但源码均为本人实现，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。

题目：n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始， 每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。 当一个数字删除后，从被删除数字的下一个继续删除第m个数字。 求出在这个圆圈中剩下的最后一个数字。

题目分析：

　　这个题目是一个约瑟夫环的问题，下面给出两种解决方案。

(一) 运用单循环链表解决。

　　这种方案能按顺序输出每次删除的元素，需要一个有n个结点的环形列表来模拟这个删除的过程，因此内存开销为O(n)。每删除一个数字需要m步运算，总共有n个数字，因此总的时间复杂度是O(mn)。当m和n都很大的时候，这种方法是很慢的。

　　算法思想：假设已经建立了一个不带头节点的单循环链表，设置计数器count(初始化为1)统计在扫描循环链表的过程中是否技术到m,如果count=m,则输出该节点的编号并删除该节点,遍历的指针往后移动，count复位为1；否则遍历的指针往后移动，count++。

　　算法实现：

    //运用循环单链表的方式实现
    private void josephusList(Node first, int n, int m){
        if(n < 1 || m < 1)  
            return;
        if(n==1){
            System.out.print(first.data+" ");
        }
        else{
            Node pre = first;  //当前节点的前驱
            Node p = first.next; //当前节点
            int count = 2;
            while(p!=pre){
                if(count==m){
                    System.out.print(p.data+" ");
                    Node r = p.next;  //删除当前节点
                    pre.next = r;
                    p=r;
                    count = 1;
                }
                else{
                    pre = p;
                    p = p.next;
                    count++;
                }
            }
            System.out.println("\n最后一个删除的元素:"+p.data);
        }
    }

(二) 运用数学分析找出规律,快速求解。

　　首先：定义最初的n个数字（0,1,…,n-1）中最后剩下的数字是关于n和m的方程为f(n,m)。 在这n个数字中，第一个被删除的数字是m%n-1，为简单起见记为k。那么删除k之后的剩下n-1的数字为0,1,…,k-1,k+1,…,n-1，并且下一个开始计数的数字是k+1。相当于在剩下的序列中，k+1排到最前面，从而形成序列k+1,…,n-1,0,…k-1。该序列最后剩下的数字也应该是关于n和m的函数。由于这个序列的规律和前面最初的序列不一样（最初的序列是从0开始的连续序列），因此该函数不同于前面函数，记为f’(n-1,m)。最初序列最后剩下的数字f(n,m)一定是剩下序列的最后剩下数字f’(n-1,m)，所以   f(n,m)=f’(n-1,m)   。
　　然后：来我们把剩下的的这n-1个数字的序列k+1,…,n-1,0,…k-1作一个映射，映射的结果是形成一个从0到n-2的序列：

　　k+1     ->     0 
　　k+2     ->     1 
　　… 
　　n-1     ->     n-k-2 
　　0        ->     n-k-1 
　　… 
　　k-1     ->     n-2 

　　1）把这个映射定义为p，则p(x)= (x-k-1)%n，即如果映射前的数字是x，则映射后的数字是(x-k-1)%n。

　　2）对应的逆映射是p逆(x)=(x+k+1)%n，即如果映射后的数字是x，则映射前的数字是(x-k-1)%n。

　　由于映射之后的序列和最初的序列有同样的形式，都是从0开始的连续序列，因此仍然可以用函数f来表示，记为f(n-1,m)。根据我们的映射规则，映射之前的序列最后剩下的数字f’(n-1,m)= p逆 [f(n-1,m)]=[f(n-1,m)+k+1]%n。把k=m%n-1代入得到f(n,m)=f’(n-1,m)=[f(n-1,m)+m]%n。 
　　经过上面复杂的分析，我们终于找到一个递归的公式。要得到n个数字的序列的最后剩下的数字，只需要得到n-1个数字的序列的最后剩下的数字，并可以依此类推。当n=1时，也就是序列中开始只有一个数字0，那么很显然最后剩下的数字就是0。我们把这种关系表示为：

         　　　　　　 0                  　　　 　　　　 n=1 
　　　　f(n,m)={ 
          　　　　　　[f(n-1,m)+m]%n    　　  　　n>1 

　　注意：f(n,m)这个函数只能用于返回最后一个输出的数字，而不能用于求出过程中每次输出的数字。f(n,m)表示求出[0,1,2...,n-1]中最后一个输出的元素，f(n-1,m)表示求出[0,1,2...,n-2]中最后一个输出的元素.

　　算法的递归实现：

    //递归的思想 ,省去了m和n的检查
    private int LastRemaining(int n,int m)  {  
        if(n == 1 ) { 
            return 0;
        }
        else
            return (LastRemaining(n-1,m)+m)%n;
    } 

　　算法的非递归实现：

 

    //非递归的思想 ,省去了m和n的检查
    private int lastRemain1(int n,int m)  {  
        int last = 0;
        for(int i=2;i<=n;i++){
            last = (last+m)%i;
        }
        return last;
    }

 

java 实现的完整源码：

package com.interview;

/**
 * n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，
 * 每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。
 * 当一个数字删除后，从被删除数字的下一个继续删除第m个数字。
 * 求出在这个圆圈中剩下的最后一个数字。
 * @author wjh
 *
 */
public class _18JosephCycle {

    /**
     * @param args
     */
    public static void main(String[] args) {
        _18JosephCycle invoker = new _18JosephCycle();
        int n = 17,m=5;
        System.out.println("1)这是用递归的思想求得的最后删除的元素：");
        System.out.println(invoker.lastRemain(n, m)+"\n");
        System.out.println("2)这是用非递归的思想求得的最后删除的元素：");
        System.out.println(invoker.lastRemain1(n, m)+"\n");
        System.out.println("3)这是用单循环链表实现的依此删除的删除的元素：");
        Node first = invoker.cycleList(n);
        invoker.josephusList(first, n, m);
    }

    //递归的思想 ,省去了m和n的检查
    private int lastRemain(int n,int m)  {  
        if(n == 1 ) { 
            return 0;
        }
        else
            return (lastRemain(n-1,m)+m)%n;
    }
    
    //非递归的思想 ,省去了m和n的检查
    private int lastRemain1(int n,int m)  {  
        int last = 0;
        for(int i=2;i<=n;i++){
            last = (last+m)%i;
        }
        return last;
    }
    
    
    //运用循环单链表的方式实现
    private void josephusList(Node first, int n, int m){
        if(n < 1 || m < 1)  
            return;
        if(n==1){
            System.out.print(first.data+" ");
        }
        else{
            Node pre = first;  //当前节点的前驱
            Node p = first.next;  //当前节点
            int count = 2;
            while(p!=pre){
                if(count==m){
                    System.out.print(p.data+" ");
                    Node r = p.next;  //删除当前节点
                    pre.next = r;
                    p=r;
                    count = 1;
                }
                else{
                    pre = p;
                    p = p.next;
                    count++;
                }
            }
            System.out.println("\n最后一个删除的元素:"+p.data);
        }
    }
    
    
    //创建带头节点的无环单链表,真正的节点有m个
    private Node cycleList(int n){
        Node first = new Node(0,null);    //头节点
        Node r = first;   //指向链表的尾节点
        for(int i=0;i<n;i++){  
            Node node = new Node(i,null);
            r.next = node;
            r = node;
        }
        first = first.next;
        r.next = first;       //若是构建无环单链表，此处   r.next = null;
        return first;
    }
    
    //创建一个泛型节点类
    class Node {
        public int data;
        public Node next;
        public Node() {
            super();
        }
        public Node(int data, Node next) {
            super();
            this.data = data;
            this.next = next;
        }
    }
}

运行结果：

这是用递归的思想求得的最后删除的元素：
10

这是用非递归的思想求得的最后删除的元素：
10

这是用单循环链表实现的依此删除的删除的元素：
4 9 14 2 8 15 5 12 3 13 7 1 0 6 11 16
最后一个删除的元素:10