约瑟夫环java简单实现
『壹』 如何用java实现约瑟夫环问题急！
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
int number;
int mima;
struct node * next;
}Node, *Link;
Link Init(void)
{
Link L;
L = (Link)malloc(sizeof(Node));
L->next = L;
return L;
}
void Insert(Link L, int e_mima, int e_number)
{
Link p,q;
p = (Link)malloc(sizeof(Node));
p->mima = e_mima;
p->number = e_number;
q = L;
while(q->next != L)q = q->next;
p->next = q->next;
q->next = p;
}
void Delete(Link L, int i)
{
Link p,q;
q = L;
while(q->next != q && q->next->number != i)
q = q->next;
if(q->next->number == i)
{
p = q->next;
q->next = p->next;
free(p);
}
}
void main()
{
Link p,q,L;
int i,m,n,mima;
printf("请输入人数和初始密码：");
scanf("%d%d",&n,&m);
if(n<=0 || m<=0)return;
L = Init();
i=1;
while(i<=n)
{
printf("请输入第 %d 个人的密码：",i);
scanf("%d",&mima);
if(mima <= 0)continue;
Insert(L, mima, i);
i++;
}
i = 1;
p = L->next;
while(L->next != L)
{
q = p;
p = p->next;
if(p ==L)
{
q = p;
p = p->next;
}
i++;
if(i == m)
{
printf("%d\t",p->number);
m = p->mima;
Delete(L, p->number);
p = q;
i = 0;
}
}
}
『贰』 java编程序实现约瑟夫环
精简易懂版本 刚写的
public class Yuesefu {
// 数三退一 约瑟夫环 求最后留在环中小朋友的位置 即原来的编号(1-500)
/**
* 初始化数组，添加标号
*/
private void markID(int[] child) {
for (int i = 0; i <= child.length - 1; i++) {
child[i] = i + 1;
}
}
/**
* 求出小孩子原来的位置在什么地方，从一开始
*/
public void re_index(int[] i) {
for (int ii : i) {
if (ii > 0) {
System.out.println("还在场内的小朋友的序号为 : " + ii);
}
}
}
/**
* 统计剩余的同学
*/
public int record(int[] re) {
int reco = 0;
for (int i : re) {
if (i > 0) {
reco = reco + 1;
} else {
continue;
}
}
// System.out.println("目前还剩下：" + reco + " 个小朋友在圈圈里面");
System.out.println("程序努力加载计算中.............................................................................................." + reco);
return reco;
}
public static void run() {
int childs[] = new int[500];
Yuesefu yuesefu = new Yuesefu();
yuesefu.markID(childs);
yuesefu.startGame(childs);
yuesefu.re_index(childs);
}
/**
* 游戏开始
*/
private void startGame(int[] i) {
int index = 0; // 用作循环
int leave = 0; // 用作离场
while (true) {
if (i[index] != 0) {// 还在场内
leave = leave + 1; // 报数
if (leave == 3) {// 判断是否需要离场 需要
i[index] = 0; // 离场
leave = 0;// 重新报数
}
index = index + 1;// 下一个人预备
if (index == i.length) {// 已经到最后了 需重新循环
index = 0;
}
} else {// 不在场内
if (index == i.length - 1) {// 判断此出场的人是否为最后一个人
index = 0;
}
index = index + 1;// 跳过
}
int x = new Yuesefu().record(i);// 统计剩余人数
if (x == 1)
break;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
run();
}
}
『叁』 约瑟夫环的JAVA实现，在原有基础上添加界面，事件处理还有异常处理，简单即可，发邮箱[email protected]
import java.util.LinkedList;
/*
* @author Love yali_deng forever
*/
public class YueSeFu {
/*
* 约瑟夫环是一个数学的应用问题：
* 已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个
* 人出 列；
* 他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
* @param args
*/
private static StringBuffer removedStr = new StringBuffer("");// 记录出列的数字
public static void main(String[] args) {
long startTime = System.currentTimeMillis(); // 获取开始时间
process(5000,10,1);
System.out.println(removedStr.substring(0,removedStr.length() - 1));
long endTime = System.currentTimeMillis(); // 获取结束时间
String str="程序运行时间：" + (endTime - startTime)+"ms";
System.out.println(str);
}
public static void process(int n,int k,int m) {
// 构建一个list，存放人数
LinkedList<Integer> list = new LinkedList<Integer>();
for (int i = 0; i < n; i++) {
if (i + k > n) {
list.add(i + k - n);
} else {
list.add(i + k);
}
}
int count = 1;// 记录数的人数
cycleCal(list,count,m);
}
public static void cycleCal(LinkedList<Integer> list,int count,int m){
int len = list.size();
if (len > 1) {
for (int i = 0; i < len; i++) {
if (count == m) {// 第m个时，remove
removedStr.append(list.get(i)).append(",");
list.remove(i);
len = list.size();
i--;
count = 0;
}
count++;
}
cycleCal(list,count,m);
}
else if(len != 0){
removedStr.append(list.get(0)).append(",");
}
}
}
『肆』 java循环单链表实现约瑟夫环
看了你的代码，不是很明白，给你提几个建议吧：
1、不需要tail节点
2、remove方法应该对删除节点前面的节点操作，而不是使用数字找
给你我修改的LinkList类，你参考一下：
publicclassLinkList{
privateNodehead;
intcurlen=0;
//创建链表
publicvoidcreatelist(intcode)throwsException{
insert(curlen,code);
}
publicvoidinsert(inti,intcode)throwsException{
Nodes=newNode(code);
if(i==0){
s.setNext(head);
head=s;
}
Nodep=head;
intj=0;
while(p!=null&&j<i-1){
p=p.getNext();
j++;
}
if(j>i||p==null){
thrownewException("插入位置不合理");
}
s.setNext(p.getNext());
p.setNext(s);
// tail=s;
// tail.setNext(head);
curlen=curlen+1;
}
publicvoidremove(inti)throwsException{
Nodep=head,q=null;
intj=0;
i=i-1;
while(j<i){
q=p;
p=p.getNext();
j++;
}
if(j>i||p==null)
thrownewException("删除位置不合法");
if(q==null){
// tail.setNext(p.getNext());
head=head.getNext();
}else
q.setNext(p.getNext());
curlen=curlen-1;
}
/**
*按照节点删除
*@parami
*@throwsException
*/
publicvoidremove(Nodep)throwsException{
if(p.getNext()==p){
p=null;
head=null;
}
else{
Nodeq=p.getNext();
p.setNext(q.getNext());
}
curlen=curlen-1;
}
publicvoidout(intm)throwsException{
Nodep=head;
if(m==1){
System.out.print("按照顺序出列");
return;
}
intcount=1;
intn=m-1;
while(curlen>0){
if(count==n){
System.out.print(p.getNext().getData()+"");
remove(p);
count=1;
}else{
count++;
}
p=p.getNext();
}
}
publicvoiddisplay(){
Nodenode=head;
for(inti=0;i<2*curlen;i++){
System.out.print(node.getData()+"");
node=node.getNext();
}
System.out.println();
}
}
『伍』 约瑟夫环java实现报错，菜鸟求解
问题原型：
传说在很久很久以前，有一架搭载着n个人的飞机出现了故障，迫降在了一个荒岛上。飞机彻底报废后，这些人用飞机的残骸建成了一艘只能容纳一个人乘坐的小船，那么怎么去确定这n个人中哪个人有资格上船呢？于是，这n个人采用了下面的方式来解决这个困境。
问题描述：
假设有N个人围成一圈，每个人都有从1到N的唯一顺序编号。接下来从编号为1的人开始顺序报数。报到M号的人退出这个圈。然后由下一个人重新由1开始进行报数，如此循环往复，那么最终留下来的是编号为多少的那个人呢？
java编程代码实现：
import java.util.Scanner;
public class countMethod {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//接收用户输入，获得总人数N
System.out.println("请输入参与的总人数：");
int N=sc.nextInt();
//接收用户输入，获得出列人员的编号M
System.out.println("请输入出列的人的编号：");
int M=sc.nextInt();
//建立布尔型的数组，长度为总人数
Boolean rs[]=new Boolean[N];
//初始化布尔型数组，初始值均为true
for(int i=0;i<N;i++){
rs[i]=true;
//System.out.println(rs[i]);
}
int n=N;//剩余的人数
int m=0;//报数的编号
while(n>1){
for(int j=0;j<N;j++){
if(rs[j]){
m++;
if(m==M){
m=0;
rs[j]=false;
n--;
//System.out.println(rs[j]);
}
}
}
}
//打印出最后留下来的人员的编号
for(int k=0;k<N;k++){
if(rs[k]){
System.out.println("最后留下的是第"+(k+1)+"号。");
break;
}
}
}
}
『陆』 怎么用java数组实现约瑟夫环
用java数组实现约瑟夫环
packageJosephround;
publicclassJoseround{
intsit;
intflagjo=0;
Joseround(){};
Joseround(intx){
sit=x;
}
voidsetflag(intx){
flagjo=x;
}
}
packageJosephround;
publicclassInijose{
Joseroundjo[];
staticintlength=0;
Inijose(){};
Inijose(intx){
jo=newJoseround[x];
for(inti=0;i<x;i++){
jo[i]=newJoseround(i+1);//创建对象数组
length++;
}
}
voiddelete(intn){
for(inti=n;i<length-1;i++){
jo[i]=jo[i+1];
}
length--;
}
}
packageJosephround;
importjava.util.Scanner;
publicclassText{
publicstaticvoidmain(String[]args){
intm,n;
System.out.println("inputm");
Scannerm1=newScanner(System.in);
m=m1.nextInt();
System.out.println("inputn");
Scannern1=newScanner(System.in);
n=n1.nextInt();
inttemp=0;
intx=0;
Inijosejoseph=newInijose(n);
while(joseph.length!=0){
for(inti=1;i<=m;i++){
joseph.jo[x].setflag(i);
if(joseph.jo[x].flagjo==m){
System.out.println(joseph.jo[x].sit);
joseph.delete(x);
x--;
}
if(x<joseph.length-1)x++;
elsex=0;
}
}
}
}
『柒』 用java在数组中实现约瑟夫环的问题, 要求写明详细注释, 方法最好简单一点, 初学者,
package ysfh;
/**
* 【约瑟夫环的问题】
* 有17个人（编号从1到16），按编号依次排列成一个圆环（编号16的接着编号为1 的人），从编号为1 的人开始报数，数到3的人退出圆环，如此循环，最后留下的那个人的编号是什么？
* 1，2，3，4，5，6，7，8，，9，10，11，12，13，14，15，16
* 要求：请用面向对象的思想来处理这个问题并在下面写出具体的代码（可以选择你熟悉的语言，如java/C++/C#等）
* @author Administrator
*
*/
public class Ysfh {
public static void main(String[] args) {
m(3,16);
}
public static void m(int m,int n){
int c = 1;
int[] ns = ntoarray(n);
while(isone(ns) == false){//如果数组中有一个以上的数不为0
for (int i = 0; i < ns.length; i++) {
if(ns[i] != 0 ){//等于0的都退出了 所以从所有不等于0的开始
if(c == m){//是第三个数 给他赋值0 并让计数器c从1 开始
ns[i] = 0 ;
c = 1;
}else{//否则继续计数器下一个
c++;
}
}
}
}
//循环输出最后留下的数字
for (int i = 0; i < ns.length; i++) {
if(ns[i] != 0){//除0以外的数字 0代表删除
System.out.println(ns[i]);
}
}
}
/**
* 将 n 转换为数字 n=3 {1,2,3}
* @param n
* @return
*/
public static int[] ntoarray(int n){
int[] ns = new int[n];
for (int i = 0; i < ns.length; i++) {
ns[i] = i + 1;
}
return ns;
}
/**
* 判断数组里是否只有一个数不为0
* @param ns
* @return
*/
public static boolean isone(int[] ns){
boolean isone = false;
for (int i = 0; i < ns.length; i++) {
if(isone == false && ns[i] != 0){
isone = true;
}else if(isone == true && ns[i] != 0){
return false;
}
}
return isone;
}
}
『捌』 关于约瑟夫环问题，用java 编写程序，输出n个人出圈的顺序，书上的程序代码如下，但是有几点我搞不明白
你这个好麻烦啊， 理解 队列 和 桟 的区别
队伍 先进先出FIFO
桟 先进后出 LIFO
本程序明显是队伍！！！
importjava.util.*;
publicclassT{
publicstaticvoidmain(String[]args){
List<Integer>list=newLinkedList<Integer>();
//模拟15个人，编号是1-15
for(inti=1;i<=15;i++){
list.add(i);
}
//模拟叫到7的人出圈
show(list,7);
}
publicstaticvoidshow(List<Integer>list,intn){
inti=1;//每次报的数字
intcount=1;//记录第几次出圈
while(true){
//当list长度为1的时候代表就剩下1个人
if(list.size()==1){
System.out.println("第"+count+++"次是"+list.get(0));
return;
}
//每次获取队里第一个人
intvalue=list.get(0);
//报完数后移开该人
list.remove(0);
//如果报数的人报的数字为n,则打印
if(i==n){
i=1;
System.out.println("第"+count+++"次是"+value);
}else{
//如果报数的人报的数字不是n,将该人排到队伍的后面，以便下次继续叫号
list.add(value);
//产生下次报数的数字
i++;
}
}
}
}
『玖』 java编程实现约瑟夫问题
publicclassRingTest{
publicstaticvoidmain(String[]args){
System.out.println("程序说明如下：");
System.out.println("由m个人围成一个首尾相连的圈报数。从第一个人开始，从1开始报数，报到n的人出圈，剩下的人继续从1开始报数，直到所有的人都出圈为止。对于给定的m和n，求出所有人的出圈顺序.");
//提示输入总人数
System.out.println("请输入做这个游戏的总人数：");
Scannersca=newScanner(System.in);
intm=sca.nextInt();
//提示输入要出圈的数值
System.out.println("请输入要出圈的数值：");
intn=sca.nextInt();
System.out.println("按出圈的次序输出序号：");
//创建有m个值的数组
int[]a=newint[m];
//初始长度，以后出圈一个，长度就减一
intlen=m;
//给数组赋值
for(inti=0;i<a.length;i++)
a[i]=i+1;
//i为元素下表，j代表当前要报的数
inti=0;
intj=1;
while(len>0){
if(a[i%m]>0){
if(j%n==0){//找到要出圈的人，并把圈中人数减一
System.out.print(a[i%m]+"");
a[i%m]=-1;
j=1;
i++;
len--;
}else{
i++;
j++;
}
}else{//遇到空位了，就跳到下一位，但j不加一，也就是这个位置没有报数
i++;
}
}
}
}
『拾』 约瑟夫环问题——猴子选大王，用java编写
帮帮忙,谢谢啊