锐客网

  1. 首页 > 睿知 > it技术 > >

java汉诺塔代码讲解 汉诺塔c++代码

IT技术盘子

如何用java实现汉诺塔中的递归public class Hannuota {
private int n;//储存盘子个数
public Hannuota(int n){
this.n = n;
}
public void function(){
//初始化三个柱子java汉诺塔代码讲解，A是开始堆满盘子的柱子java汉诺塔代码讲解 ， 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上 。
根据圆盘的数量确定柱子的排放顺序java汉诺塔代码讲解：若n为偶数，按顺时针方向依次摆放 A B C；
若n为奇数，按顺时针方向依次摆放 A C B 。
（1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时 ， 若圆盘1在柱子A，则把它移动到B；
若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A 。
（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上 。
即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时 ， 移动较小的圆盘
这一步没有明确规定移动哪个圆盘，java汉诺塔代码讲解你可能以为会有多种可能性，其实不然，可实施的行动是唯一的 。
（3）反复进行（1）（2）操作 ， 最后就能按规定完成汉诺塔的移动 。
这玩意要非递归真麻烦 。需不需要加点注释java汉诺塔代码讲解？
其实我不明白干嘛非要非递归 。。。
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 盘子; //返回盘子
}
}
-----------------------另外说一下，楼主太抠门了?。。。。。。。≈桓?分-----------------------
用java实现汉诺塔的程序是啥呀？其实不知道你到底是想要代码还是要什么
给你帖的示范代码吧：
汉诺塔问题的递归Java语言实现
public
class
Hanoi
{/**
*
*
@param
n
*
盘子的数目
*
@param
origin
*
源座
*
@param
assist
*
辅助座
*
@param
destination
*
目的座
*/
public
void
hanoi(int
n,
char
origin,
char
assist,
char
destination)
{
if
(n
==
1)
{
move(origin,
destination);
}
else
{
hanoi(n
-
1,
origin,
destination,
assist);
move(origin,
destination);
hanoi(n
-
1,
assist,
origin,
destination);
}
}
//
Print
the
route
of
the
movement
private
void
move(char
origin,
char
destination)
{
System.out.println("Direction:"
origin
"---"
destination);
}
public
static
void
main(String[]
args)
{
Hanoi
hanoi
=
new
Hanoi();
hanoi.hanoi(3,
'A',
'B',
'C');
}
}
JAVA程序归递算法求解汉诺塔问题首先你需要有下面这两个意识：
1.一个函数对于其它函数来说相当于一个盒子 ， 他封装了其中的内容，其它函数只知道给它参数，然后得到它的结果 。就好比一个做蛋糕的商店：我们只需要知道给钱，它就会给蛋糕 。而我们不需要理解他们是怎么做出来的这个蛋糕 。
2.调用的过程，就相当于上面例子中我们去买蛋糕的过程 。谁说自己不能买自己店里的蛋糕呢？比如你是做蛋糕的，难道你不能买自己店里的蛋糕吗？函数的自我调用（递归？）也是这么回事情 。
对于hanoi类里面，两个核心函数：
move（char getme, char purone):
这个函数的功能是：把getme最上面的盘子移动到purone位置，比如
move('A','B')就是把A柱子最上面那个盘子移动到B柱子的最上面 。
hanoi(int n,char one,char two,char three）：
这个函数的功能是：现在在柱子one上一共有n个盘子，这个函数能够通过two把它移动到three上面 。
现在你了解了这两个函数设计的初衷 ， ok ， 我们来分别实现每个函数 。
public void move(char getme,char purone)
{//请联系上面写的这个函数的功能来看：
c=c 1;//我们每移动一步，就计数一次
System.out.println(getme "--" putone "搬盘次数为：" c);
//这行使用输出来表明移动过了（事实上hanoi就是要让你详细说明移动过程，所谓“说明”，就是打印出每次的移动，那这里我们就把这次移动打印出来，这个没有任何问题吧？这个函数就是要把移动这件事情说出来，明白？
}
public void hanoi(int n,char one,char two,char three)
{//请回忆hanoi函数的功能，是要把one柱子上的前n个放到three柱子上：
if(n==1) //如果n==1,那也就是要把one柱子上最上面的那个移到three上面了，这就是move函数的作用 ， 对吧？那就直接调用move(one,three)
move(one,three);
else{
//如果n1的话，那我们该怎么办？
分为三个步骤：
1.先想办法把one主子上的前n-1个移动到柱子two上
2.然后把one柱子上的第n个移动到柱子three上 。
3.然后想办法把two柱子上的n-1个移动到three上 。
对吧？现在你注意到第1步和第3步是不是就是hanoi这个函数的功能能够实现的呢？回答显然是肯定的，下面就是这三步 。
hanoi(n-1,one,three,two); //把one柱子上的n-1个通过three移动到two上 。
move(one,three); //把one主子上最上面那个（注意，上面一步已经把前n-1个移动到two上面了，one柱现在最上的那个就是第N个）
hanoi(n-1,two,one,three);//把two柱子上的n-1个移动到three柱子上 。
}
}
解释到这里，main函数里面的调用应该也就很明白了吧？
a.hanoi(m,'A','B','C')；
把'A'柱子上的m个盘子通过'B'柱子全部移动到'C'上面的步骤 。
解释起来很容易，想得多了也就慢慢明白了，最难的是如何设计一个递归出来 。这个和数学里面的递推公式很相似（事实上其来源就是递推公式），想必你肯定知道递增函数把？ An = An-15（A0 = 0 );这个条件能够唯一确定一个数列 。
那现在你把它写成函数呢？
int A(int n) {
if(n == 0) {
return 0;
} else {
return A(n -1)5;
}
}
调用A(n)就能返回An的值 。明白？
多想想 ， 多练练，大家都是这么过来的：）祝好运
怎样用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("请输入盘数java汉诺塔代码讲解：");
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
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汉诺塔代码讲解 汉诺塔c 代码】java汉诺塔代码讲解的介绍就聊到这里吧，感谢你花时间阅读本站内容 ， 更多关于汉诺塔c代码、java汉诺塔代码讲解的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：Redis设计与实现 pdf下载 redis设计与实现

    下一篇：苏州服务器突然黑屏了应该怎么处理？ 苏州服务器黑屏怎么办