JAVA编程问题：求汉诺塔非递归JAVA代码

一、JAVA编程问题:求汉诺塔非递归JAVA代码

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

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

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

4、 Pillar[] pillars= new Pillar[3];

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

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

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

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

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

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

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

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

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

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

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

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

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

18、 public static void main(String args[]){

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

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

21、 public Pillar(int max,String name){

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二、如何做一个C语言编程的汉诺塔游戏要有源代码。

1、 printf("%c-->%c\n",x,y);

2、 void hanoi(int n,char one,char two,char three)

3、 printf("input the number of disks:");

4、 printf("the step to moving%3d diskes:\n",m);

5、 hanoi(m,'A','B','C');

6、其实算法非常简单，当盘子的个数为n时，移动的次数应等于2^n– 1（有兴趣的可以自己证明试试看）。后来一位美国学者发现一种出人意料的简单方法，只要轮流进行两步操作就可以了。首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上，根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；

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

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

9、（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘。这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。

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

11、所以结果非常简单，就是按照移动规则向一个方向移动金片：

12、如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→C

13、汉诺塔问题也是程序设计中的经典递归问题，下面我们将给出递归和非递归的不同实现源代码。

三、高分悬赏Java程序,急!!!

public class ERS_Block extends Frame{

public static boolean isPlay=false;

public static int level=1,score=0;

public static TextField scoreField,levelField;

public static void main(String[] argus){

ERS_Block ers= new ERS_Block("俄罗斯方块游戏 V1.0 Author:Vincent");

WindowListener win_listener= new WinListener();

ers.addWindowListener(win_listener);

setLayout(new GridLayout(1,2));

gameScr.addKeyListener(gameScr);

rightScr.setLayout(new GridLayout(2,1,0,30));

MyPanel infoScr= new MyPanel();

infoScr.setLayout(new GridLayout(4,1,0,5));

Label scorep= new Label("分数:",Label.LEFT);

Label levelp= new Label("级数:",Label.LEFT);

Label namep= new Label("姓名：张三",Label.LEFT);

Label nump= new Label("学号:110821332",Label.LEFT);

scoreField= new TextField(8);

levelField= new TextField(8);

scoreField.setEditable(false);

levelField.setEditable(false);

scorep.setSize(new Dimension(20,60));

scoreField.setSize(new Dimension(20,60));

levelp.setSize(new Dimension(20,60));

levelField.setSize(new Dimension(20,60));

MyPanel controlScr= new MyPanel();

controlScr.setLayout(new GridLayout(5,1,0,5));

Button play_b= new Button("开始游戏");

play_b.setSize(new Dimension(50,200));

play_b.addActionListener(new Command(Command.button_play,gameScr));

Button level_up_b= new Button("提高级数");

level_up_b.setSize(new Dimension(50,200));

level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));

Button level_down_b=new Button("降低级数");

level_down_b.setSize(new Dimension(50,200));

level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));

Button pause_b=new Button("游戏暂停");

pause_b.setSize(new Dimension(50,200));

pause_b.addActionListener(new Command(Command.button_pause,gameScr));

Button quit_b= new Button("退出游戏");

quit_b.setSize(new Dimension(50,200));

quit_b.addActionListener(new Command(Command.button_quit,gameScr));

controlScr.add(level_down_b);

//重写MyPanel类，使Panel的四周留空间

return new Insets(30,50,30,50);

class GameCanvas extends Canvas implements KeyListener{

final int unitSize= 30;//小方块边长

int maxAllowRowNum;//允许有多少行未削

int blockInitRow;//新出现块的起始行坐标

int blockInitCol;//新出现块的起始列坐标

blockInitCol= columnNum/2- 2;

//初始化屏幕，并将屏幕数组清零的方法

for(int j=0; j<columnNum;j++)

public void paint(Graphics g){

for(int i= 0; i< rowNum; i++)

for(int j= 0; j< columnNum; j++)

public void drawUnit(int row,int col,int type){

switch(type){//表示画方快的方法

case 0: g.setColor(Color.black);break;//以背景为颜色画

case 1: g.setColor(Color.blue);break;//画正在下落的方块

case 2: g.setColor(Color.magenta);break;//画已经落下的方法

g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize,true);

return b;//返回block实例的引用

//返回屏幕数组中(row,col)位置的属性值

public int getScrArrXY(int row,int col){

if(row< 0|| row>= rowNum|| col< 0|| col>= columnNum)

return(blockInitRow);//返回新块的初始行坐标

return(blockInitCol);//返回新块的初始列坐标

for(int i=0;i<rowNum;i++){

L1:for(int j=0;j<columnNum;j++)

for(int j= 0; j< columnNum; j++){

scrArr[k-1][j]= scrArr[i][j];

for(int i= k-1;i< rowNum; i++){

for(int j= 0; j< columnNum; j++){

ERS_Block.score+= full_line_num;

ERS_Block.scoreField.setText(""+ERS_Block.score);

for(int col= 0; col<columnNum; col++){

if(scrArr[maxAllowRowNum][col]!=0)

public void keyTyped(KeyEvent e){

public void keyReleased(KeyEvent e){

public void keyPressed(KeyEvent e){

case KeyEvent.VK_DOWN:b.fallDown();break;

case KeyEvent.VK_LEFT:b.leftMove();break;

case KeyEvent.VK_RIGHT:b.rightMove();break;

case KeyEvent.VK_SPACE:b.leftTurn();break;

class Command implements ActionListener{

static final int button_play= 1;//给按钮分配编号

static final int button_levelup= 2;

static final int button_leveldown= 3;

static final int button_quit= 4;

static final int button_pause= 5;

static boolean pause_resume= true;

Command(int button,GameCanvas scr){

public void actionPerformed(ActionEvent e){

case button_play:if(!ERS_Block.isPlay){

ERS_Block.scoreField.setText("0");

case button_levelup:if(ERS_Block.level< 10){

ERS_Block.levelField.setText(""+ERS_Block.level);

ERS_Block.scoreField.setText(""+ERS_Block.score);

case button_leveldown:if(ERS_Block.level> 1){

ERS_Block.levelField.setText(""+ERS_Block.level);

ERS_Block.scoreField.setText(""+ERS_Block.score);

case button_pause:if(pause_resume){

case button_quit:System.exit(0);

{0x0f00,0x4444,0x0f00,0x4444},//用十六进至表示，本行表示长条四种状态

{0x04e0,0x0464,0x00e4,0x04c4},

{0x4620,0x6c00,0x4620,0x6c00},

{0x2640,0xc600,0x2640,0xc600},

{0x6220,0x1700,0x2230,0x0740},

{0x6440,0x0e20,0x44c0,0x8e00},

int blockType;//块的模式号（0-6）

int turnState;//块的翻转状态（0-3）

int blockState;//快的下落状态

int row,col;//块在画布上的坐标

blockType=(int)(Math.random()* 1000)%7;

turnState=(int)(Math.random()* 1000)%4;

blockType=(int)(Math.random()* 1000)%7;

turnState=(int)(Math.random()* 1000)%4;

if(assertValid(blockType,(turnState+ 1)%4,row,col)){

if(assertValid(blockType,turnState,row,col-1)){

if(assertValid(blockType,turnState,row,col+1)){

if(assertValid(blockType,turnState,row-1,col)){

boolean assertValid(int t,int s,int row,int col){

if((int)(pattern[t][s]&k)!= 0){

int temp= scr.getScrArrXY(row-i,col+j);

public synchronized void dispBlock(int s){

if(((int)pattern[blockType][turnState]&k)!= 0){

public MyTimer(GameCanvas scr){

sleep((10-ERS_Block.level+ 1)*100);

catch(InterruptedException e){}

if(!scr.getBlock().fallDown()){

class WinListener extends WindowAdapter{

public void windowClosing(WindowEvent l){