汉诺塔java
publicclassHannoi{
publicstaticvoidmain(String[]args){
intnDisks=3;
moveDish(nDisks,'A','B','C');
}
privatestaticvoidmoveDish(intlevel,charfrom,charinter,charto){
if(level==1){
System.out.println("从"+from+"移动盘子"+level+"号到"+to);
}else{
moveDish(level-1,from,to,inter);
System.out.println("从"+from+"移动盘子"+level+"号到"+to);
moveDish(level-1,inter,from,to);
}
}
}
⑵ 如何用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;i<max;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;i<max;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编写汉诺塔程序
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版汉诺塔的演示程序
源代码：
/**
*本程序完成的功能是利用汉递规算法实现汉诺塔的动态演示程序
*/
import javax.swing.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.*;
public class Hanio extends JApplet implements ActionListener, Runnable
{
/**
*diskNum是盘子的数量
*/
private int diskNum ;
/**
*各个组件的句柄
*/
private JButton begin, stop;
private JLabel lDiskNum;
private JTextField text;
JPanel pane;
/**
*定义一个线程句柄
*/
private Thread animate;
/**
*定义a,b,c三个柱子上是否有盘子，有哪些盘子
*/
private int adisk[];
private int bdisk[];
private int cdisk[];
public void init()
{
Container content = getContentPane();
content.setLayout(new BorderLayout());
lDiskNum = new JLabel(盘子的数目);
text = new JTextField(8);
begin = new JButton(开始);
begin.addActionListener(this);
stop = new JButton(停止);
stop.addActionListener(this);
pane = new JPanel();
pane.setLayout(new FlowLayout());
pane.add(lDiskNum);
pane.add(text);
pane.add(begin);
pane.add(stop);
content.add(pane, BorderLayout.SOUTH);
}
public void paint(Graphics g)
{
Graphics2D g2D = (Graphics2D)g;
Ellipse2D.Double ellipse;
g2D.setPaint(getBackground());
if(adisk != null)
{
/**
*消除以前画的盘子
*/
for(int j=adisk.length, i=0; --j>=0; i++ )
{
ellipse = new Ellipse2D.Double(20+i*5, 180-i*10, 180-i*10, 20);
g2D.fill(ellipse);
ellipse = new Ellipse2D.Double(220+i*5, 180-i*10, 180-i*10, 20);
g2D.fill(ellipse);
ellipse = new Ellipse2D.Double(420+i*5, 180-i*10, 180-i*10, 20);
g2D.fill(ellipse);
}
drawEllipse(g, 20, adisk);//画A组盘子
drawEllipse(g, 220, bdisk);//画B组盘子
drawEllipse(g, 420, cdisk);//画C组盘子
}
pane.repaint();
}
public void update(Graphics g)
{
paint(g);
}
/**画出椭圆代表盘子，g是图形环境，x是最下面的盘子的横坐标，
*arr是柱子数组
*/
public void drawEllipse(Graphics g,int x,int arr[])
{
Graphics2D g2D = (Graphics2D)g;
Ellipse2D.Double ellipse;
g2D.setPaint(Color.gray);
g2D.draw(new Line2D.Double(x+90, 10, x+90, 180));
for(int j=arr.length, i=0; --j>=0; i++ )
if(arr[j] != 0)
{
if(i%2 == 0)
g2D.setPaint(Color.blue);
else
g2D.setPaint(Color.red);
ellipse = new Ellipse2D.Double(x+i*5, 180-i*10, 180-i*10, 20);
g2D.fill(ellipse);
}
}
public void actionPerformed(ActionEvent e)
{
String command = e.getActionCommand();
if(command.equals(开始))
{
/**
*进行初始化，开始的时候只有a柱子上有盘子，其他柱子都没有
*/
diskNum = Integer.parseInt(text.getText());
adisk = new int[diskNum];
for(int i=0; i<adisk.length; i++)
adisk[i] = 1;
bdisk = new int[diskNum];
for(int k=0; k<bdisk.length; k++)
bdisk[k] = 0;
cdisk = new int[diskNum];
for(int i=0; i<cdisk.length; i++)
cdisk[i] = 0;
repaint();
if(animate == null || !animate.isAlive())//创建一个线程
{
animate = new Thread(this);
animate.start();
}
}
if(command.equals(停止))
{
for(int k=0; k<bdisk.length; k++)
bdisk[k] = 0;
for(int i=0; i<cdisk.length; i++)
cdisk[i] = 0;
repaint();
text.setText();
animate = null;
}
}
/**
*线程方法，在此调用汉诺塔执行移动盘子操作
*/
public void run()
{
hanio(diskNum, 'A', 'B', 'C');
repaint();
}
/**
*汉诺塔递规调用程序，n是盘子的数量，A，B，C分别代表三个柱子
*/
public void hanio(int n, char A, char B, char C)
{
if(n > 1)
{
hanio(n-1, A, C, B);
pause();//停顿几秒在执行
switch(A)
{
case 'A':adisk[n-1] = 0;break;
case 'B':bdisk[n-1] = 0;break;
case 'C':cdisk[n-1] = 0;break;
default:break;
}
switch(C)
{
case 'A':adisk[n-1] = 1;break;
case 'B':bdisk[n-1] = 1;break;
case 'C':cdisk[n-1] = 1;break;
default:break;
}
repaint();
hanio(n-1, B, A, C);
}
pause();
switch(A)
{
case 'A':adisk[n-1] = 0;break;
case 'B':bdisk[n-1] = 0;break;
case 'C':cdisk[n-1] = 0;break;
default:break;
}
switch(C)
{
case 'A':adisk[n-1] = 1;break;
case 'B':bdisk[n-1] = 1;break;
case 'C':cdisk[n-1] = 1;break;
default:break;
}
repaint();
}
/**
*每隔半妙钟移动一个盘子
*/
public void pause()
{
try{
Thread.sleep(500);//可以修改此值加快盘子移动的速度
}catch(InterruptedException e){}
}
}
⑸ 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.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSpinner;
import javax.swing.JTextArea;
import javax.swing.SpinnerModel;
import javax.swing.SpinnerNumberModel;
public class Test {
public static void main(String[] args) {
JFrame frame = new JFrame();
SpinnerModel sm = new SpinnerNumberModel(5, 5, 9, 1);
final JSpinner spinner = new JSpinner(sm);
final JTextArea area = new JTextArea(20, 20);
JButton button = new JButton("OK");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
area.setText(solveHanoi((Integer) spinner.getValue()));
}
});
JPanel choicePanel = new JPanel();
choicePanel.add(spinner);
choicePanel.add(button);
frame.add(choicePanel, BorderLayout.NORTH);
frame.add(new JScrollPane(area), BorderLayout.SOUTH);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
private static String solveHanoi(int level) {
StringBuilder sb = new StringBuilder();
solveHanoi(sb, 1, 3, 2, level);
return sb.toString();
}
private static void solveHanoi(StringBuilder sb, int source, int dest,
int middle, int level) {
if (level == 1) {
sb.append(source).append("-->").append(dest).append("\n");
} else {
solveHanoi(sb, source, middle, dest, level - 1);
sb.append(source).append("-->").append(dest).append("\n");
solveHanoi(sb, middle, dest, source, level - 1);
}
}
}
⑺ 用java实现汉诺塔的实现过程。 递归实现
import java.io.*;
public class Hanoi {
public static void main(String args[]) 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汉诺塔怎么实现退步和下一步的操作呢
你是想实现一个演示汉诺塔
移动过程的程序吗?
1.首先，计算移动过程的核心有吗？
如果用的是递归的方法实现的。
那么return处作一下限制。（这是初步思想，具体细节，要自己调试。）
⑼ 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分-----------------------