「Java汉诺塔大学教吗」汉诺塔java实现

今天给各位分享Java汉诺塔大学教吗的知识，其中也会对汉诺塔java实现进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、怎样用Java编写汉诺塔程序
• 2、java 汉诺塔问题
• 3、如何用java实现汉诺塔中的递归
• 4、JAVA汉诺塔
• 5、java中汉诺塔的算法问题
• 6、java实现汉诺塔的代码，求注释，具体到每一行代码，急求，，，

怎样用Java编写汉诺塔程序

package Hanoi;

import java.awt.*;

import java.io.*;

import java.awt.event.*;

public class Hanoi {

public static void main(String args[]) throws IOException {

Hanoi aa = new Hanoi();

aa.go();

}

public void go() throws IOException {

int n;

BufferedReader buf;

buf = new BufferedReader(new InputStreamReader(System.in));

System.out.print("请输入盘数：");

n = Integer.parseInt(buf.readLine());

Hanoi hanoi = new Hanoi();

hanoi.move(n, 'A', 'B', 'C');

}

public void move(int n, char a, char b, char c) {

if (n == 1) {

System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);

} else {

move(n - 1, a, c, b);

System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);

move(n - 1, b, a, c);

}

}

}

java 汉诺塔问题

ABC做3个stack栈

在A中初始化 3 2 1，

A to C 就是 c.push(a.pop());

A to B 就是 b.push(a.pop())

B to C 就是 c.push(b.pop())

就这样就能得到结果了。不需要去管移动的是那个数

如何用java实现汉诺塔中的递归

public class Hannuota {

private int n;//储存盘子个数

public Hannuota(int n){

this.n = n;

}

public void function(){

//初始化三个柱子，A是开始堆满盘子的柱子，C是目标柱子

Pillar a = new Pillar(n,n,"A");

Pillar b = new Pillar(n,"B");

Pillar c = new Pillar(n,"C");

//把三个柱子按顺序排好，详见后面的算法那里的解释

Pillar[] pillars = new Pillar[3];

pillars[0] = a;

if(n%2==0){

pillars[1] = b;

pillars[2] = c;

}else{

pillars[1] = c;

pillars[2] = b;

}

//开始移动，k用来计数，移动次数为2^n-1,至于为什么，我不太清楚，

//反正有人证明过。i是用来保存最小那个盘子正在哪跟柱子上的。

int i=0;

for(int k=0;k(int)Math.pow(2, n)-1;){

int min;

//将最小的盘子顺时针移动一个柱子

min = pillars[i%3].Pop();

pillars[(i+1)%3].Push(min);

System.out.println(pillars[i%3]+"-"+pillars[(i+1)%3]);

k++;

i++;

//这个IF好像可以不要，当时写的，后面忘了删除。

if(k(int)Math.pow(2, n)-1){

//如果，剩下两根柱子中，某一根为空，则一定是非空那根中最上面个盘子

//移动到空的那个柱子上。若两根都不为空，则把编号小的一个盘子

//移动到另外跟柱子上

if(!pillars[(i-1)%3].isEmpty()(pillars[(i+1)%3].isEmpty()||pillars[(i+1)%3].Top()pillars[(i-1)%3].Top())){

min=pillars[(i-1)%3].Pop();

pillars[(i+1)%3].Push(min);

System.out.println(pillars[(i-1)%3]+"-"+pillars[(i+1)%3]);

}else{

min=pillars[(i+1)%3].Pop();

pillars[(i-1)%3].Push(min);

System.out.println(pillars[(i+1)%3]+"-"+pillars[(i-1)%3]);

}

k++;

}

}

}

//主函数，用来测试的。3表示3个盘子。

public static void main(String args[]){

new Hannuota(3).function();

}

}

class Pillar{//构造一个新类，表示柱子，实际是当一个栈在用

private int[] s;

private int top;

private String name;

public String toString(){

return name;

}

//这个构造函数用来构造BC两个柱子，下面那个用来构造柱子A。其实也可以写成一个构造函数。

public Pillar(int max,String name){

s = new int[max];

top = -1;

this.name = name;

for(int i=0;imax;i++){

s[i] = max+1;

}

}

public Pillar(int n,int max,String name){

s = new int[max];

top = n-1;

this.name = name;

for(int i=0;imax;i++){

s[i] = max - i;

}

}

//这后面这些就是栈的基本方法了，不用介绍了吧

public boolean isEmpty(){

return top==-1?true:false;

}

public int Top (){

return s[top];

}

public int Pop(){

return s[top--];

}

public void Push(int x){

s[++top] = x;

}

}

算法是这个

首先容易证明，当盘子的个数为n时，移动的次数应等于2^n - 1。

首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上。

根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；

若n为奇数，按顺时针方向依次摆放 A C B。

（1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；

若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。

（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。

即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘

这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。

（3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。

这玩意要非递归真麻烦。需不需要加点注释？

其实我不明白干嘛非要非递归。。。

JAVA汉诺塔

import java.awt.*;

public class TowerPoint //公共类TowerPoint

{

int x,y; //定义2个int类型的变量

boolean 有盘子; //定义一个boolean类型的变量

Disk 盘子=null; //初始化一个对象"盘子"并赋值为空

HannoiTower con=null; //初始化一个HannoiTower类的对象"con"并赋值为空

public TowerPoint(int x,int y,boolean boo) //构造函数，有3个参数，x，y，boo

{

this.x=x; //将参数赋给当前x

this.y=y; //将参数赋给当前y

有盘子=boo; //将boo赋给"有盘子"

}

public boolean 是否有盘子() //定义一个返回boolean类型的方法"是否有盘子"

{

return 有盘子; //返回boolean类型的"有盘子"

}

public void set有盘子(boolean boo) //set方法，并且参数为boolean

{

有盘子=boo; //将boo赋给有盘子

}

public int getX() //取得x方法

{

return x; //返回x

}

public int getY()//取得y方法

{

return y; //返回y

}

public void 放置盘子(Disk 盘子,HannoiTower con) //定义一个有2个参数的"放置盘子"方法。参数是Disk类和HannoiTower类

{

this.con=con; //当前con等于参数con

con.setLayout(null); //调用on对象的方法setLayout，并设置为空

this.盘子=盘子; //当前盘子等于参数盘子

con.add(盘子); //con对象的add方法，加入"盘子"对象

int w=盘子.getBounds().width; //定义并给一个int类型的w变量一个值，值为"盘子.getBounds().width"

int h=盘子.getBounds().height; //定义并给一个int类型的h变量一个值，值为"盘子.getBounds().height"

盘子.setBounds(x-w/2,y-h/2,w,h);//调用"盘子"对象的setBounds方法，并把传递值

有盘子=true;//boolean类型的对象"有盘子"等于true

con.validate(); //调用con对象的validate方法

}

public Disk 获取盘子() //定义"获取盘子"方法，方法返回Disk对象

{

return 盘子; //返回盘子

}

}

-----------------------另外说一下，楼主太抠门了！！！！！！！！只给5分-----------------------

java中汉诺塔的算法问题

class HanRuoTa {

static long s=0;

public static void main(String args[]) {

int n =3;

System.out.println("汉诺塔层数为" + n);

System.out.println("移动方案为：" );

hanoi(n, 'a', 'b', 'c');

System.out.println("需要移动次数："+s);

}

static void hanoi(int n, char a, char b, char c) {

if (n 0) {

hanoi(n - 1, a, c, b);

move(a, b);

hanoi(n - 1, c, b, a);

s++;

}

}

static void move(char x, char y) {

System.out.println(x + "-" + y + "\t");

}

}

运行结果：

汉诺塔层数为3

移动方案为：

a-b

a-c

b-c

a-b

c-a

c-b

a-b

需要移动次数：7

java实现汉诺塔的代码，求注释，具体到每一行代码，急求，，，

这样应该可以了 如果还有那个地方不懂的，建议你研究下汉诺塔算法

import java.io.BufferedReader;//引入IO包中的BufferedReader

import java.io.IOException;//引入IO包中的IO异常处理

import java.io.InputStreamReader;//引入IO包中的InputStreaReader

public class Hinoi { //主类

static int m=0;//定义移动的次数

//主程序入口——main方法

public static void main(String[] args) {

//创建BufferedReader对象,InputStream输入流

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

System.out.println("请输入盘子的个数：");

try {

int sl = Integer.parseInt(bf.readLine().toString());//接收总盘子个数

toMove(sl,"A","B","C");//调用移动方法 A——C

} catch (NumberFormatException e) {捕获NumberFormatException异常

// TODO Auto-generated catch block

e.printStackTrace();//打印异常

} catch (IOException e) {//捕获IOException异常

// TODO Auto-generated catch block

e.printStackTrace();//打印异常

}

System.out.println("总共移动了："+m+" 次数");//打印移动次数

}

//移动方法

private static void toMove(int sl, String one, String two,String three)

{

if(sl==1){//如果只有一个盘子，则直接移动到C柱

System.out.println("盘子"+sl+" 从 "+one+"----"+three);

}else{//如果总盘数大于1，则递归调用移动方法

//把所有的数量为sl-1的盘子全部从A移到到B（C作为一个过渡），好提供一个最下面的位置给最大盘子到C；

toMove(sl-1,one,three,two);

System.out.println("盘子"+sl+" 从 "+one+"----"+three);

//把所有的剩余的盘子从B移动到C（A作为一个过渡）

toMove(sl-1,two,one,three);

}

m++;

}

}

关于Java汉诺塔大学教吗和汉诺塔java实现的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。