思路：
先把人的编号存储在一数组里面，然后找到第一个开始报数的人，然后把第一个报数的人利用数组排序把他掉到前面去，然后开始报数，在把报到特定数的后面的元素往前移一位，一直到把所有的数储存到另外一个数组。
可以用各种语言写，只要原理对了就行！

帮你编辑了

方法：可以用数组来存放N个数，相当于N个数排成的圈；用整型变量指向当前数到的数组元素，
相当于人的手指；划掉一个数的操作，就用将一个数组元素置0的方法来实现。人工数的时候，要跳过已
经被划掉的数，那么程序执行的时候，就要跳过为0的数组元素。注意，当指向当前数到的数组元素的整
型变量指向数组中最后一个元素（下标为N-1）时,再数下一个，则该整型变量要指回到数组的第一个元
素（下标为0），这样才像一个圈。

1. import java.util.LinkedList;
   
2. import java.util.List;
   

复制代码

1. /**
   
2. * 约瑟夫环问题的一种描述是：编号为1.2.3…….n的n个人按顺时针方向围坐一圈 ，每人手持一个密码（正整数），
   
3. * 开始任意选一个整数作为报数上限值，从第一个人开始顺时针自1开始顺序报数，报到m时停止报数。报m的人出列，
   
4. * 将他的密码作为新的m值，从他顺时针下一个人开始重新从1开始报数，
   
5. * 如此下去直到所有的人全部都出列为止。试设计程序实现，按照出列的顺序打印各人的编号。
   
6. * @author Administrator
   
7. *
   
8. */
   
9. public class Question2 {
   
10. class person {
    
11. int password;
    
12. int number;
    
13. int state = 1;
    
14. 
    
15. public person(int password, int number) {
    
16. this.password = password;
    
17. this.number = number;
    
18. }
    
19. public person(int number){
    
20. this.number = number;
    
21. }
    
22. }
    
23. 
    
24. public int ListLength(List<person> list) {
    
25. int count = 0;
    
26. if (list != null) {
    
27. for (person p : list) {
    
28. if (p.state != 0) {
    
29. count++;
    
30. }
    
31. }
    
32. }
    
33. return count;
    
34. }
    
35. 
    
36. public void cacle() {
    
37. // 初始化数据
    
38. List<person> list = new LinkedList<person>();
    
39. list.add(new person(3,1));
    
40. list.add(new person(1,2));
    
41. list.add(new person(7,3));
    
42. list.add(new person(2,4));
    
43. list.add(new person(4,5));
    
44. list.add(new person(8,6));
    
45. list.add(new person(4,7));
    
46. 
    
47. int position = -1;//初始位置
    
48. int m = 20; //第一次报多少的人出来
    
49. int count = 0;//已经报了多少人
    
50. while (ListLength(list) != 0) {
    
51. 
    
52. position = (position + 1) % list.size();// 位置定位
    
53. 
    
54. if (((person) list.get(position)).state != 0) {
    
55. count++;
    
56. }
    
57. if (count == m) {
    
58. person p = list.get(position);
    
59. System.out.print(p.number+" ");
    
60. p.state = 0;
    
61. m = p.password;
    
62. list.set(position, p);
    
63. count = 0;
    
64. }
    
65. }
    
66. 
    
67. 
    
68. }
    
69. public static void main(String[] args) {
    
70. Question2 q= new Question2();
    
71. q.cacle();
    
72. }
    
73. 
    
74. }
    
75. 
    

复制代码

1. 
   
2. public class Test {
   
3.         
   
4.         public static int[] Joshphus(int start,int step,int size){        //start:从第几个人开始,step:报多少数走一个,size:一共多少人
   
5.                 int[] arInt=new int[size];
   
6.                 //1.初始化数组,把每个人编上号
   
7.                 for(int i=0;i<size;i++)
   
8.                         arInt[i]=i;
   
9.                 //2.先把开始报数的人挪到最前面的位置,就是arInt[0]
   
10.                 for(int i=start;i!=0;i--){
    
11.                         int temp=arInt[0];
    
12.                         for(int j=0;j<size;j++){
    
13.                                 if(j!=size-1)
    
14.                                         arInt[j]=arInt[j+1];
    
15.                                 else
    
16.                                         arInt[j]=temp;
    
17.                         }
    
18.                 }
    
19.                 //3.开始报数
    
20.                 int currentSize=size;                        //还剩多少人
    
21.                 int p=0;                                                //该第几个人报数了
    
22.                 int num=1;                                                //报数报到几了
    
23.                
    
24.                 while(currentSize>0){
    
25.                         if(num==step){                                //报到step,这哥们出列了
    
26.                                 int temp=arInt[p];          //出列的哥们要放到数组最后,先把他存起来
    
27.                                 for(int i=p;i<size-1;i++)
    
28.                                         arInt[i]=arInt[i+1];
    
29.                                 arInt[size-1]=temp;
    
30.                                 num=1;
    
31.                                 if(p==--currentSize)        //这里p就不用前移了,因为后面的人已经自动顶上来了
    
32.                                         p=0;                                //但是p指向最后一个的话,要把p挪到最前面去
    
33.                         }else{                                                //还没报到step
    
34.                                 num++;
    
35.                                 if(++p==currentSize)
    
36.                                         p=0;
    
37.                         }
    
38.                 }        
    
39.                 return arInt;
    
40.         }
    
41.         
    
42.         public static void main(String[] args){
    
43.                 int[] arInt=Joshphus(2,3,7);
    
44.                 for(int i:arInt)
    
45.                         System.out.print(i+" ");
    
46.         }
    
47.         
    
48. }
    

复制代码

去掉每一个元素后还是一个约瑟夫环，所以，可以使用递归实现，网上相关的代码很多，这个就还可以，http://zhidao.baidu.com/question/260915453.html

先占个楼 晚点写代码

1. package cn.itcast.demo;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class ThreePointDemo {
   
6. 
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 int dropNumber=0;
   
10.                 int count=0;
    
11.                 List<String> list=new LinkedList<String>();
    
12.                 for(int number=1;number<=12;number++)//这里设置你要存入多少人；
    
13.                 {
    
14.                         list.add("person number:"+number);
    
15.                 }       
    
16.                 while(list.size()!=0)//核心程序代码
    
17.                 {
    
18.                         if(count==4)//这里设置你要的报号的数字我设置的为4；
    
19.                         {
    
20.                                 int midparam=--dropNumber;
    
21.                                 if(midparam<0)
    
22.                                 {
    
23.                                         midparam=list.size()-1;
    
24.                                 }                               
    
25.                                 System.out.println("the drop number is : number"+list.remove(midparam));
    
26.                                 count=0;
    
27.                                 print(list);
    
28.                                 System.out.println();
    
29.                         }
    
30.                         count++;
    
31.                         dropNumber++;
    
32.                         if(list.size()==0)break;
    
33.                         dropNumber=dropNumber%list.size();
    
34. 
    
35.                 }
    
36.        
    
37.         }
    
38.         public static void print(List<String> list)//为了打印方便做的函数print
    
39.         {
    
40.                 for(Iterator it=list.iterator();it.hasNext();)
    
41.                 {
    
42.                         System.out.print(it.next());
    
43.                 }
    
44.                
    
45.         }
    
46. }
    

复制代码

要是c程序的话，还比较行，用习惯指针了，java的逻辑就有点冗余了。结果如图：

public class MainClass {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int[] src ={1,2,3,4,6,5,7};
                int[] dest = new int[src.length];
                numOff(src,dest,3);
        }
        /**
         *
         * @param source 原报数编号数组
         * @param dest 新报数编号数组
         * @param remove  特定的号数
         */
        public static void numOff(int[] source,int[] dest,int remove){
                int[] src = source;
                int[] des = dest;
                int i = 0;
                int k = 0;
                int length = src.length;
                int d = 0;
                while(length>=1){
                        if(i==length){
                                i=0;
                        }
                        k++;
                        if(k!=remove){
                                i++;
                                continue;
                        }
                        //报到特定的号数时，把这个编号赋值到新的数组
                        if(k==remove){
                                des[d] = src[i];
                                //特定号数后面的元素向前移动
                                for(int a = i;a<src.length;a++){
                                        if(a+1==src.length){
                                                break;
                                        }
                                        src[a]=src[a+1];
                                }
                                d++;
                                k=0;//剩下的人重新报号
                                length--;//每有一个报特定号数，数组长度的值减一
                        }
                       
                }
        }
}
应该是这样的吧？！

1. Console.WriteLine("请输入参与游戏的人数：");
   
2. int numPerson = int.Parse(Console.ReadLine());//读取转换赋予
   
3. 
   
4. Console.WriteLine("请输入游戏退出的规则数：");
   
5. int ruleNum = int.Parse(Console.ReadLine());//读取转换赋予
   
6. 
   
7. bool[] person = new bool[numPerson]; //定义每个人是否退出开关，默认为否
   
8. int callNum = 0; //报数
   
9. int total = 0; //记录已经退出的人数
   
10. int index = -1; //报数的循环游标
    
11. 
    
12. while (true) {
    
13. 
    
14. index++; //从第一个人开始
    
15. index %= numPerson; //确保数组不越界，当游标指向最后一个数组元素以后，从头开始
    
16. 
    
17. if (!person[index]) { //第index个人没有退出时，则进行报数
    
18. 
    
19. callNum++;
    
20. }
    
21. if (callNum == ruleNum) { //当第index个人报数的数字与规则数相同时，则开关打开，退出报数
    
22. 
    
23. person[index] = true;
    
24. total++; //退出的总人数更新
    
25. callNum = 0; //为下一个人报数更新数据
    
26. Console.WriteLine("玩家{0}退出",index+1);
    
27. }
    
28. if ((numPerson - total) == 1) { //当游戏玩家只剩下一个的时候结束游戏
    
29. 
    
30. for (int i = 0; i < person.Length; i++) {
    
31. 
    
32. if (person[i] == false) { // 判断退出开关依然是否的玩家
    
33. 
    
34. Console.WriteLine("最后剩下的玩家是第：{0}位",i + 1); //输出实际的玩家号
    
35. break;
    
36. }
    
37. }
    
38. break;
    
39. }
    
40. }

复制代码

C#选手，菜鸟了，别怪啊，呵呵

好久以前的一道作业题,...记得那时候是使用C语言的链表来做的.

package testSomething;

import java.util.Scanner;

/**
* 先把人的编号存储在一数组里面，然后找到第一个开始报数的人，然后把第一个报数的人利用数组排序把他掉到前面去，然后开始报数，
* 在把报到特定数的后面的元素往前移一位，一直到把所有的数储存到另外一个数组。 可以用各种语言写，只要原理对了就行！
*/
public class JSF {
        public static void main(String[] args) {
                while (true) {
                        System.out.println("请输入总数：输入0结束");
                        Scanner sca = new Scanner(System.in);
                        int m = sca.nextInt();
                        if (m == 0) {
                                System.out.println("结束");
                                System.exit(0);
                        }
                        System.out.print("请输入报数周期：\n");
                        int n = sca.nextInt();
                        System.out.print("按出圈的次序输出序号：\n");

                        int[] a = new int[m];
                        int len = m;
                        for (int i = 0; i < a.length; i++)
                                a[i] = i + 1;
                        // i为元素下标
                        int i = 0;
                        // j代表当前要报的数
                        int j = 1;
                        while (len > 0) {
                                // 以m为周期的一个循环，在数组中按m周期不停报数
                                int t = i % m;
                                if (a[t] > 0) {
                                        int w = j % n;
                                        if (w == 0) {// 找到要出圈的人，并把圈中人数减一
                                                System.out.print(a[t] + "  ");
                                                a[t] = -1;
                                                j = 1;
                                                i++;
                                                len--;
                                        } else {
                                                i++;
                                                j++;
                                        }
                                } else {// 遇到空位了，就跳到下一位，但j不加一，也就是这个位置没有报数
                                        i++;
                                }
                        }
                        System.out.println();
                }
        }
}

黑马高明辉 发表于 2012-7-20 23:33
package testSomething;

import java.util.Scanner;

哥，分！

任务已经解决，锁帖