漢諾塔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分-----------------------