算法练习-单链表约瑟夫环的O(n)算法

这个题表示技巧性有点强，我感觉不推荐这么干，但是还是记录学习下吧！

环形单链表的约瑟夫问题
【题目】
据说著名犹太历史学家 Josephus 有过以下故事:在罗马人占领乔塔帕特后,39 个犹太人
与 Josephus 及他的朋友躲到一个洞中,39 个犹太人决定宁愿死也不要被敌人抓到,于是
决定了一个自杀方式,41 个人排成一个圆圈,由第 1 个人开始报数,报数到 3 的人就自
杀,然后再由下一个人重新报 1,报数到 3 的人再自杀,这样依次下去,直到剩下最后一 个人时,那个人可以自由选择自己的命运。这就是著名的约瑟夫问题。现在请用单向环形链
表描述该结构并呈现整个自杀过程。 输入:一个环形单向链表的头节点 head 和报数的值 m。
返回:最后生存下来的节点,且这个节点自己组成环形单向链表,其他节点都删掉。 【要求】
如果链表节点数为 N,请实现时间复杂度为 O(N)的解法。

在我们自然的算法上，很容易想到直接循环删除报数为m的节点，这个算法的复杂度为O（n*m）；

代码如下：

    // 自然方法
    public static Node getNode1(Node head,int m){
        if(head==null || head.next==head || m<1){
            return head;
        }

    Node last=head;
    while(last.next!=head){
        last=last.next;
    }

    int count=0;
    while(last!=head){
        if(++count==m){
            // kill head
            last.next=head.next;
            count=0;
        }else{
            last=last.next;
        }
        head=last.next;
    }

    return head;
}

如果想要实现O(N)的算法，首先需要两个 对应转换函数：
1） 报数 与 编号之间的对应关系(假设一共有i个数)

  报数（A）          编号(B)
  1                 1
  2                 2
  ...               ...
  i                 i
  i+1               1
  i+2               2
  ...               ...
  2*i-1             i-1
  2*i               i
  ...               ...

从上面的关系可以得到：B=(A-1)%i+1

2）删除时 新的链表 和 旧链表之间的对应关系：

长度为i时：   1     2    ... s-2 s-1 s s+1 s+2 ... i
假设删除的节点编号为s
长度为i-1时： i-s+1 i-s+2... i-2 i-1 () 1   2  ... i-s

也就是当删除s时新的链表（长度i-1）和原链表（长度为i）的编号对应关系如上，表达式可为：

old = （new+s-1）% i +1

由1）和2）两个关系式可得（s和m的关系就是编号和报数的关系）：

old = （new+m-1）% i +1   （1）

因此：要计算长度为n的链表最终存活了哪个节点，可以根据 （1）式 的 长度为n-1 存活的节点得到，依次递归，直到长度为1的节点 肯定存活编号为1；再依次回退，计算原链表存活的节点编号；

代码：

    // 非自然方法
    public static Node getNode2(Node head,int m){
        if(head==null || head.next==head || m<1){
            return head;
        }

    // 计算长度
    Node cur=head.next;
    int tmp=1;
    while(cur!=head){
        tmp++;
        cur=cur.next;
    }

    tmp=getLive(tmp,m);

    while(--tmp!=0){
        head=head.next;
    }
    head.next=head;

    return head;
}

public static int getLive(int i,int m){
    if(i==1){
        return 1;
    }

    return (getLive(i-1,m)+m-1)%i+1;
}

虽然这种方法的时间复杂度相比第一种低，但我觉得也太难想到了，不是好评~