约瑟夫环的java解决

总共3中解决方法，1、数学推导，2、使用ArrayList递归解决，3、使用首位相连的LinkedList解决

import java.util.ArrayList;

/**
* 约瑟夫环问题
* 需求：n个人围成一圈，从第一个人开始报数，数到K的人出局，然后从下一个人接着报数，直到最后一个人，求最后一个人的编号
* @author Miao
*
*/
public class Josephus {
public static void main(String[] args) {
int n = 13;
int k = 3;
int last;
// last =getLast(n,k); //使用数学推导求结果
/* 使用递归求结果
* ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 1; i <= n; i++) {
list.add(i);
}
last = getLast(list, k,0); //从下标为0开始报数，
*/
// System.out.println(last);
/**
* 使用链表方式求结果，链表为头尾相接的环形链表
*/

MyLinkedList list = new MyLinkedList();
for (int i = 1; i <= n; i++) {
list.add(i);
}
//只要链表中元素个数大于1个，则指向下面步骤
while(list.length>1){
Node temp = list.first; //获得头节点
//将temp节点从头节点向后挪k个位置
for (int i = 1; i < k; i++) {
temp = temp.next;
}

System.out.println("被移除的编号为："+temp.value);
list.remove(temp); //移除当前temp位置的节点
System.out.println("剩余元素为："+list.toString()+",长度为"+list.length);
}
//当上面循环结束时，链表内只剩1个元素
last = list.first.value;
System.out.println(last);
}
/**
* 数学推导，已知圈内只有一个人时候，剩余的是编号1，根据推导，如果当圈内有n-1个人时剩余的人编号为last，
* 那么当圈内有n人时，剩余的人的编号是last+k，因为可能last+k以后大于了当前圈内人数，所以剩余的
* 人的编号为(last+k)%n，但这时就会出现如果last+k后指向最后一个人，这时得到的编号为0，不符合要
* 求，所以用((last+k-1)%n)+1，这样最后一个人报的数也是自己了，而其他位置的人报数不变。
*
* @param n 圈内人数
* @param k 数到该数字的人出局
* @return 剩余人的编号
*/
public static int getLast(int n , int k){

int last = 1; //这是初始值，即环内为1个人时剩余的人的编号，必然为1，也是后面推导的基础
//System.out.println("当环内有1个人时，剩余的是:1");
for (int i = 2; i <= n; i++) { //当圈内为i个人时，结果是圈内为i-1个人的结果加K后对i求余
last = ((last + k - 1) % i) + 1; //为避免出现结果为0，让i-1的结果先减1，求余后再加1
//System.out.println("当环内有" + i + "个人时，剩余的是:" + last);
}
return last;
}

/**
* 递归方式：第一轮根据传入的集合、开始下标和间隔求出第一轮出局的人的下标，然后将该人移出集合，
* 并求出下一轮的开始下标，然后迭代调用本方法，将剩余集合元素和新的开始下标传入计算，
* 直至剩余最后一个元素，就是最后存货的元素
* @param list 传入的集合
* @param k 报数到K的人出局
* @param m 从下标为m的人开始报数
* @return 剩余最后一个人的编号
*/
public static int getLast(ArrayList<Integer> list, int k , int m){
int last = -1; //用来放置最后一个人的编号
int index = -1; //用来放置当前一轮被移除的人的下标
if (list.size() == 1) { // 如果集合内只剩一个元素，则直接返回该元素作为结果
last = list.get(0);
} else {
index = (m + k - 1) % list.size(); // 求出当前一轮被移除的人的下标
/* System.out.println("当前集合内的元素为：" + list.toString());
System.out.println("从" + list.get(m) + "开始报数,被移除的是:"
+ list.get(index));*/
list.remove(index); // 将该人移除
m = index % list.size(); // 求出新一轮报数时开始的人在新集合里的下标
last = getLast(list, k, m); // 使用剩余的集合和m的位置重新开始下一轮计算
}
return last;
}

}

/**
* 定义一个双向节点类，用作实现链表功能
* @author Miao
*
*/
class Node{
Integer value;
Node next;
Node prev;
public Node(){
value = null;
prev=null;
next = null;
}
public Node(Integer value){
this.value = value;
next = null;
prev = null;
}
public String toString(){
return this.prev.value+"<"+this.value+">"+this.next.value;
}
}
/**
* 定义自己的双向链表类，用来放置数据
* @author Miao
*
*/
class MyLinkedList{
public Node first;
public Node last;
public int length;
public MyLinkedList(){
first = new Node();
last = first;
length = 0;
}
//在链表结尾增加元素的方法
public void add(Integer i){
if(length == 0){
first.value = i; //添加第一个元素，只需要设置该元素的value
}else{
Node temp = new Node(); //添加元素时，1、新建一个元素，
temp.value = i;
temp.prev = last; //2、然后先与last节点建立双向关系，
last.next = temp;
first.prev = temp; //3、再与first节点建立双向关系，
temp.next = first;
last = temp; //4、最后让last指向该节点，3、4步可颠倒
}

length++;
}
//从链表中删除指定节点的方法
public void remove(Node node){
node.prev.next = node.next; //将前节点的next跳过本节点，指向下个节点
node.next.prev = node.prev; //将后节点的prev跳过本节点，指向前节点 ，此时该节点已经从链表中移除了
this.first = node.next; //指定后节点为头节点
this.last = node.prev; //指定前节点为尾节点
node = null;
length--;
}

public String toString(){
String str ="[";
Node temp = first;
for (int i = 1 ; i < length; i++ ) {
str += temp.value+",";
temp = temp.next;
}
str += (temp.value+"]");
return str;
}

}