本文目录一览：
高分求解java约瑟夫环问题
package josephus
/**
* pTitle: Josephus/p
* pDescription: This is a algorithm to display Josephus/p
* pCopyright: Copyright (c) 2007/p
* pCompany: BHL/p
* @author Linpeizhong
* @version 1.0
*/
import javax.swing.JLabel;
import javax.swing.border.Border;
import java.awt.Color;
import javax.swing.BorderFactory;
import java.awt.SystemColor;
/**节点类，用于每个节点属性的定义*/
class Node {
int flag; //序号
Node next; //指针
int mima; //密码
JLabel jLabel; //拥有的标签
//构造器方法，用于实现每个节点的密码序号m，密码n，标签JLabel
public Node(int m, int n, JLabel jLabel) {
flag = m;
mima = n;
this.jLabel = jLabel;
}
}
/**主功能类，用于运行时的界面控制*/
public class MainSrc {
//节点数
int s = 12;
//初始密码
int cs = 0;
//定义节点数组
int a[] = new int[s];
//声明界面类MainApplet的对象
MainApplet mainApplet;
//边线对象
Border border, border2;
//主功能类的构造器方法，用于对象数组，初始密码，界面类的初始化
public MainSrc(int a[], int cs, MainApplet mainApplet) {
this.a = a;
this.cs = cs;
this.mainApplet = mainApplet;
//调用初始化方法
init();
}
//初始化方法
public void init() {
//当点击主界面的按钮“开始”时，将调用MainSrc这个功能类，调用后“开始”按钮应该设置为不可用
mainApplet.jButton2.setEnabled(false);
//红色边线
border = BorderFactory.createLineBorder(Color.red, 10);
//系统控制的颜色的边线，也就是黑色边线
border2 = BorderFactory.createLineBorder(SystemColor.controlText, 1);
//赋值
int m1 = a[0], m2 = 0, m3 = cs;
//节点1的实现
Node a1 = new Node(1, m1, mainApplet.jLabels[0]);
//当前节点定位为节点a1
Node index = a1;
//初始化a1后的各个节点
for (int i = 2; i = s; i++) { //初始化每个人
//通过密码数组的元素赋值密码
m2 = a[i - 1];
//让当前的节点的指针域指向下个节点
index.next = new Node(i, m2, mainApplet.jLabels[i - 1]);
//让当前节点的下个节点成为当前节点
index = index.next;
}
/**通过上面的赋值后，index最后定位在最后一个节点上，也就是第12个节点上，让
* 最后一个节点的指针域指向节点a1，这样就构造出了一个带有节点Node的循环单链表
*/
index.next = a1;
//当i=s时，循环结束，出队完毕
for (int i = 0; i s; i++) {
for (int j = 0; j m3 - 1; j++) {
index = index.next;
//让所有人的边线为黑色
for (int z = 0; z mainApplet.jLabels.length; z++) {
mainApplet.jLabels[z].setBorder(border2);
}
//轮到报数的人的边线为红色
index.jLabel.setBorder(border);
//报数时时间暂停为界面类传递过来sd变量的值，而sd是通过JSlider来设置的，因而JSlider可以调节报数速度
try {
Thread.sleep(mainApplet.sd);
}
catch (InterruptedException ex1) {
ex1.printStackTrace();
}
}
//设置出列的前一位的边线为原先的颜色
index.jLabel.setBorder(border2);
//设置该出列的人的边线为
index.next.jLabel.setBorder(border);
//让红色边线在将要出列的人的地方停留时间tostop，同样也是通过组件JSlider调节
try {
Thread.sleep(mainApplet.toStop);
}
catch (InterruptedException ex2) {
ex2.printStackTrace();
}
//测试时使用，用于在控制台显示将要出列的人的号数
System.out.println("第" + index.next.flag + "人出局");
//在界面类的状态窗口显示出列情况
mainApplet.jTextArea1.append(index.next.flag + " ");
//让出列的号数的标签为不可见
index.next.jLabel.setVisible(false);
try {
Thread.sleep(1000);
}
catch (InterruptedException ex) {
}
//把出列的号所拥有的密码为运行的密码
m3 = index.next.mima;
//删除节点，其实在链表中是让指针指向改变而已，这是出列，也是算法的重点
index.next = index.next.next;
}
//让所有的标签的边线为原先的颜色
for (int z = 0; z mainApplet.jLabels.length; z++) {
mainApplet.jLabels[z].setBorder(border2);
}
//
mainApplet.jTextArea1.append("n哈哈，测试结束结束啦！n请观察测试的数据是不是和你想的一样呢？"+
"n不妨点击一下显示图片按钮,看图更形象哦^_^");
//参数导入按钮设置为可用
mainApplet.jButton1.setEnabled(true);
//显示图片按钮设置为可用
mainApplet.jButton5.setEnabled(true);
//清除所有的密码标签内容
mainApplet.setNull();
}
}
我花钱买的
求解约瑟夫环问题(Java)
package 约瑟夫环;
import java.util.LinkedList;
import java.util.List;
/**
* 约瑟夫环问题的一种描述是：编号为1.2.3…….n的n个人按顺时针方向围坐一圈 ，每人手持一个密码（正整数），
* 开始任意选一个整数作为报数上限值，从第一个人开始顺时针自1开始顺序报数，报到m时停止报数。报m的人出列，
* 将他的密码作为新的m值，从他顺时针下一个人开始重新从1开始报数，
* 如此下去直到所有的人全部都出列为止。试设计程序实现，按照出列的顺序打印各人的编号。
* @author Administrator
*
*/
public class Question2 {
class person {
int password;
int number;
int state = 1;
public person(int password, int number) {
this.password = password;
this.number = number;
}
public person(int number){
this.number = number;
}
}
public int ListLength(Listperson list) {
int count = 0;
if (list != null) {
for (person p : list) {
if (p.state != 0) {
count++;
}
}
}
return count;
}
public void cacle() {
// 初始化数据
Listperson list = new LinkedListperson();
list.add(new person(3,1));
list.add(new person(1,2));
list.add(new person(7,3));
list.add(new person(2,4));
list.add(new person(4,5));
list.add(new person(8,6));
list.add(new person(4,7));
int position = -1;//初始位置
int m = 20; //第一次报多少的人出来
int count = 0;//已经报了多少人
while (ListLength(list) != 0) {
position = (position + 1) % list.size();// 位置定位
if (((person) list.get(position)).state != 0) {
count++;
}
if (count == m) {
person p = list.get(position);
System.out.print(p.number+" ");
p.state = 0;
m = p.password;
list.set(position, p);
count = 0;
}
}
}
public static void main(String[] args) {
Question2 q= new Question2();
q.cacle();
}
}
跟这差不多的。
怎么用java数组实现约瑟夫环
用java数组实现约瑟夫环
package Josephround;
public class Joseround {
int sit;
int flagjo=0;
Joseround(){};
Joseround(int x){
sit=x;
}
void setflag(int x){
flagjo=x;
}
}
package Josephround;
public class Inijose {
Joseround jo[];
static int length=0;
Inijose(){};
Inijose(int x){
jo=new Joseround[x];
for(int i=0;ix;i++){
jo[i]=new Joseround(i+1);//创建对象数组
length++;
}
}
void delete(int n){
for(int i=n;ilength-1;i++){
jo[i]=jo[i+1];
}
length--;
}
}
package Josephround;
import java.util.Scanner;
public class Text {
public static void main(String[] args) {
int m,n;
System.out.println("input m");
Scanner m1=new Scanner(System.in);
m=m1.nextInt();
System.out.println("input n");
Scanner n1=new Scanner(System.in);
n=n1.nextInt();
int temp=0;
int x=0;
Inijose joseph=new Inijose(n);
while(joseph.length!=0){
for(int i=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(xjoseph.length-1) x++;
else x=0;
}
}
}
}
用java解决约瑟夫问题
Java约瑟夫问题： n个人（不同id）围成一个圈，从startId(任意数)个开始报数m(任意数)个数，数m的人出列排成新队列，m清零，然后又从下一个人开始数m个数开始，数到m就出列接在新队列尾部，如此重复，知道所有人都出列为止。
package list;
import java.util.ArrayList;
* 打印 出列后的新队列
*
* eg
* int n = 10;//总人数
* int m = 3; //报数个数
* int startIndex = 1; //起点位置
* @author Hulk 2014 03 20
*
*/
public class JosephListTest {
public static void main(String[] args) {
long startTime = System.currentTimeMillis();
JosephListTest test = new JosephListTest();
int n = 10; //总人数
int m = 3; //报数个数
int startIndex = 12; //起点位置
System.out.println("JosephListTest: n= " + n + ", m= " + m +
", startIndex= " + startIndex + "nnQUEUE RESULT:");
ArrayListPerson queueList = test.queuePreson(n, m, startIndex);
for (Person person : queueList) {
System.out.println("OUT person: " + person);
}
System.out.println("use time= " +
(System.currentTimeMillis() - startTime));
}
private ArrayListPerson queuePreson(int n, int m, int startIndex) {
ArrayListPerson queueList = null;
PersonList list = createList(n);
//list.search();
if ((list != null) (list.head != null)) {
queueList = new ArrayListJosephListTest.Person();
PNode pNode = list.head;
if (startIndex 0) {
startIndex = startIndex % n;
pNode = list.getNode(startIndex);
} else {
pNode = list.head;
}
int count = 1;
while (list.size 0) {
Person outPerson = null;
//find
if (count == (m - 1)) {
//delete next node
Person prev = pNode.person;
outPerson = list.remove(prev);
queueList.add(outPerson);
//System.out.println("OUT person: " + outPerson + ", size= " + list.size);
count = 0;
}
pNode = pNode.next;
count++;
}
}
return queueList;
}
private PersonList createList(int n) {
PersonList list = new PersonList();
for (int i = 0; i n; i++) {
Person person = new Person(i, "name_" + (i + 1));
list.add(i, person);
}
return list;
}
public class PersonList {
PNode head = null;
int size = 0;
public PersonList() {
}
public PersonList(Person person) {
head = new PNode(person, head);
size++;
}
public PersonList(PNode head) {
this.head = head;
head.setNext(head);
size++;
}
public PNode getHead() {
return head;
}
public void setHead(PNode head) {
this.head = head;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public void size(int size) {
this.size = size;
}
public boolean isEmpty() {
return this.size = 0;
}
public void initHead(Person person) {
if (size == 0) {
head = new PNode(person, head);
} else {
PNode no = head;
head = new PNode(person, no);
}
size++;
}
public void add(int index, Person person) {
if (size == 0) {
head = new PNode(person, head);
head.setNext(head);
//System.out.println("head: " + head);
} else {
if (index 0) {
index = 0;
}
if (index size) {
index = size;
}
PNode no = head;
for (int i = 0; i (index - 1); i++) {
no = no.next;
}
PNode newNode = new PNode(person, no.next);
no.next = newNode;
}
size++;
}
public Person delete(int index) {
PNode pNode = remove(index);
if ((pNode != null) (pNode.next != null)) {
return pNode.next.person;
}
return null;
}
public PNode remove(int index) {
if (size == 0) {
return null;
} else {
if ((index 0) || (index = size)) {
return null;
}
}
PNode no = head;
for (int i = 0; i (index - 1); i++) {
no = no.next;
}
no.next = no.next.next;
size--;
if ((no != null) (no.next != null)) {
return no.next;
}
return null;
}
/**
* remove next node of person node, and return the deleted person
* @param prePerson
* @return removed Person
*/
public Person remove(Person prePerson) {
if (prePerson == null) {
return null;
}
if (size == 0) {
return null;
}
PNode preNode = head;
int index = -1;
for (int i = 0; i size; i++) {
if (preNode.person.id == prePerson.id) {
index = i;
break;
} else {
preNode = preNode.next;
}
}
Person remPerson = null;
if (size = 1) {
//only one node, get its person and set it as null
remPerson = preNode.person;
preNode = null;
} else {
//preNode.next.person is dest one
remPerson = preNode.next.person;
preNode.next = preNode.next.next;
}
size--;
//System.out.println("deleteing index= " + index + " : " + remPerson + ", size= " + size);
return remPerson;
}
public int update(Person src, Person dest) {
if (src == null) {
return -1;
}
int index = -1;
PNode no = head;
for (int i = 0; i size; i++) {
if (src.id == no.person.id) {
no.person = dest;
break;
} else {
no = no.next;
}
}
return index;
}
public boolean set(int index, Person person) {
if (person == null) {
return false;
}
if (size == 0) {
return false;
} else {
if ((index 0) || (index = size)) {
return false;
}
}
PNode no = head;
for (int i = 0; i index; i++) {
no = no.next;
}
no.person = person;
return true;
}
public Person get(int index) {
PNode no = getNode(index);
if (no != null) {
return no.person;
}
return null;
}
public PNode getNode(int index) {
if (size == 0) {
return null;
} else {
if ((index 0) || (index = size)) {
return null;
}
}
PNode no = head;
for (int i = 0; i index; i++) {
no = no.next;
}
return no;
}
public void search() {
int sizeLong = size;
PNode no = head;
for (int i = 0; i sizeLong; i++) {
System.out.println("search index= " + i + ", " + no);
no = no.next;
}
}
}
public class PNode {
Person person;
PNode next = null;
public PNode() {
}
public PNode(Person person) {
this.person = person;
}
public PNode(Person person, PNode next) {
this.person = person;
this.next = next;
}
@Override
public String toString() {
return "PNode [person=" + person.id + ", next=" + next.person.id +
"]";
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public PNode getNext() {
return next;
}
public void setNext(PNode next) {
this.next = next;
}
}
public class Person {
int id = 0;
String name = "";
public Person() {
}
public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
}
}
}