JAVA图形界面程序——汉诺塔演示程序代码

JAVA图形界面程序——汉诺塔演示程序代码
JAVA图形界面程序——汉诺塔演示程序代码

汉诺塔问题——JA V A实现

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.swing.JDialog;

import javax.swing.JLabel;

import javax.swing.JPanel;

class Desk extends Panel

{

Label topPanel,leftLeg,rightLeg,name;

int num; // 桌子上现有盘子的数量

public int topy=340,topx=80; //第一个个盘子在哪里放下

int maxsize=12;

int initialx=0,initialy=340;

int record[]=new int[12];

Desk(String s) //构造函数

{

name=new Label();

name.setText(s); //桌子名称

topPanel=new Label();

topPanel.setBackground(Color.red);

leftLeg=new Label();

rightLeg=new Label();

this.setSize(180, 160); //桌子面板大小

this.setLayout(null);

this.add(topPanel);

this.add(leftLeg);

this.add(rightLeg);

this.add(name);

this.setFont(new Font("宋体",Font.CENTER_BASELINE, 16));

this.setForeground(Color.blue);

topPanel.setBounds(10, 0,160, 30);

leftLeg.setBackground(Color.red);

leftLeg.setBounds(35,30,30,50);

rightLeg.setBackground(Color.red);

rightLeg.setBounds(115,30,30, 50);

name.setBounds(70, 100,60, 30);

for (int i=0;i

{

record[i]=-1;

}

}

public void Setrecord(int y) //修改记录数组

{

record[num-1]=y; //记录最上面的盘子的序号}

public void DeleoneRecord() //当移走某个盘子时,置相应的数组值为-1

{

record[num-1]=-1;

}

public void Setinitialxy(int x ) //修改下一个盘子的盘放位置

{

initialx=x;

}

public void Settopxy()

{

topx=initialx+num*5;

topy=initialy-num*10;

}

public void Settopx(int x)

{

topx=initialx+x*5;

}

public void clear()

{

num=0;

}

public void addone()

{

this.num++;

}

public void subone()

{

this.num--;

}

}

class MainPanel extends JPanel

{

//

Desk a,b,c;

int speed; //移动速度

int defaultnum=3; // 初始盘子数

boolean changnum;

int maxsize=12;

Label plate[]=new Label[maxsize];

int bigestsize=140;

int plateHeight=10;

int initialx=80;

int initialy=340;

int moveSpeed=0; //默认为快速完成

int steps=0; //完成步数

public TextField showAnswer=new TextField("结果显示区");

MainPanel()

{

for(int k=0;k

{

plate[k]=new Label();

}

a=new Desk("A座");

b=new Desk("B 座");

c=new Desk("C 座");

this.setLayout(null);

this.setSize(700, 600);

this.setBackground(Color.orange);

this.add(a);

this.add(b);

this.add(c);

this.add(showAnswer);

a.setLocation(60, 350);

b.setLocation(320,350);

c.setLocation(580,350);

showAnswer.setBounds(300, 50, 200, 25);

showAnswer.setEditable(false);

this.proplate(defaultnum); //初始化时产生的默认数量的盘子this.setSize(850,650);

this.setLayout(null);

a.Setinitialxy(80);

b.Setinitialxy(340);

c.Setinitialxy(600);

a.Settopxy();

b.Settopxy();

c.Settopxy();

changnum=false;

validate();

}

public void ChangeDefault(int x)

{

this.defaultnum=x;

changnum=true;

}

public void RemoveAllPlate()

{

for(int i=0;i

{

this.remove(plate[i]);

}

}

public void proplate(int sum)

{

showAnswer.setText("结果显示区");

steps=0;

if(changnum==true)

{

this.RemoveAllPlate();

a.clear();

b.clear();

c.clear();

a.Settopxy();

b.Settopxy();

c.Settopxy();

}

for(int su=0;su

{

plate[su].setText(" "+su);

plate[su].setBackground(Color.black);

plate[su].setForeground(Color.red);

plate[su].setV isible(true);

this.add(plate[su]);

a.addone(); //A座盘子数加1

a.Setrecord(su); //修改桌子A的记录数组

plate[su].setBounds(initialx+su*5,initialy-su*plateHeight, bigestsize-10*su,plateHeight);

}

}

public void hanoi(int n,Desk one,Desk two,Desk three)

{

if(n==1)

move(one,three);

else

{

hanoi(n-1,one,three,two);

move(one,three);

hanoi(n-1,two,one,three);

}

}

public void move(Desk one, Desk two)

{

//首先实现移动最顶端的盘子

//要做的事情包括修改相应的桌子上的盘子数,及下个盘子要放的位置,还有更新记录数组。

int no; //正在搬运的盘子的序号

double work; //取得盘子上的序号

//下面的工作是找到要移动的盘子的序号

int movewhich;

movewhich=one.record[one.num-1];

//定制移动路线

//先向上运动到制高点

int x;

int y;

x=plate[movewhich].getX();

y=plate[movewhich].getY();

two.Settopx(movewhich);

int stepleftright=(two.topx-x)/Math.abs(two.topx-x);//

while( y!=200)

{

y=y-1;

plate[movewhich].setLocation(x, y);

try {

Thread.sleep(moveSpeed);

} catch (InterruptedException e) {

// TODO 自动生成catch 块

e.printStackTrace();

}

}

//水平方向运动

while(x!=two.topx)

{

x=x+stepleftright;

plate[movewhich].setLocation(x, y);

// this.repaint();

try {

Thread.sleep(moveSpeed);

} catch (InterruptedException e) {

// TODO 自动生成catch 块

e.printStackTrace();

}

}

while(y!=two.topy)

{

y=y+1;

plate[movewhich].setLocation(x, y);

try {

Thread.sleep(moveSpeed);

} catch (InterruptedException e) {

// TODO 自动生成catch 块

e.printStackTrace();

}

}

one.DeleoneRecord(); //表示该盘子移走了

work=Double.parseDouble(plate[movewhich].getText());

no=(int)work;

System.out.print(no);

one.subone(); //盘子数减少1

two.addone(); //盘子数加1

two.Setrecord(no); //桌子2上的记录数组添加1个元素

one.Settopxy(); //修改1座上下个盘子的位置

two.Settopxy(); //修改2座... ...

//设计函数实现下面的语句

String string="当前搬运动作为:"+https://www.360docs.net/doc/9717584011.html,.getText()+"--->"+https://www.360docs.net/doc/9717584011.html,.getText();

showAnswer.setText(string);

steps++;

}

}

class MainFrame extends Frame

{

MenuBar menubar;

Menu display,help,speed,num;

MenuItem

start,quit,paush,declare,introdue,speed1,speed2,speed3,num1,num2,num3,num4,num5;

MenuActionRe replay=new MenuActionRe();

MainPanel mainpanel=new MainPanel();

MainFrame()

{

}

MainFrame(String s)

{

super(s);

setTitle(s);

menubar=new MenuBar();

display=new Menu("演示");

help=new Menu("帮助");

start=new MenuItem("开始");

speed=new Menu("选择速度");

num=new Menu("盘子数量");

quit=new MenuItem("退出");

quit.addActionListener( replay);

paush=new MenuItem("暂停");

declare=new MenuItem("说明");

introdue=new MenuItem("介绍");

speed1=new MenuItem("快速完成");

speed2=new MenuItem("适中速度");

speed3=new MenuItem("较慢实现");

num1=new MenuItem("3");

num1.addActionListener(replay);

num2=new MenuItem("5");

num2.addActionListener(replay);

num3=new MenuItem("7");

num3.addActionListener(replay);

num4=new MenuItem("9");

num4.addActionListener(replay);

num5=new MenuItem("12");

num5.addActionListener(replay);

display.add(start);

start.addActionListener(replay);

display.add(speed);

display.add(num);

display.add(quit);

speed.add(speed1);

speed1.addActionListener(replay);

speed.add(speed2);

speed2.addActionListener(replay);

speed.add(speed3);

speed3.addActionListener(replay);

num.add(num1);

num.add(num2);

num.add(num3);

num.add(num4);

num.add(num5);

help.add(declare);

declare.addActionListener(replay);

help.add(introdue);

introdue.addActionListener(replay);

menubar.add(display);

menubar.add(help);

menubar.setFont(new Font("宋体",Font.BOLD, 14));

setMenuBar(menubar);

this.add(mainpanel,BorderLayout.CENTER);

setVisible(true);

setBounds(200,50,850,650);

}

class MenuActionRe implements ActionListener

{

public void actionPerformed(ActionEvent event) {

// TODO 自动生成方法存根

if(event.getSource()==quit)

{

System.exit(0); //退出

}else if(event.getSource()==start)

{

if(mainpanel.a.num==0)

{

//说明已经搬完了,是要重新开始啦

mainpanel.proplate(mainpanel.defaultnum);

mainpanel.c.clear();

mainpanel.a.Settopxy();

mainpanel.b.Settopxy();

mainpanel.c.Settopxy();

}

mainpanel.hanoi(mainpanel.defaultnum, mainpanel.a,mainpanel.b, mainpanel.c);

mainpanel.showAnswer.setText("搬运结束,搬运次数为:"+mainpanel.steps);

}else if(event.getSource()==declare)

{

Help1 dialog=new Help1();

dialog.setVisible(true);

}else if(event.getSource()==introdue)

{

Help2 dialog=new Help2();

dialog.setVisible(true);

}else if(event.getSource()==num1)

{

mainpanel.ChangeDefault(3);

mainpanel.proplate(mainpanel.defaultnum);

}else if(event.getSource()==num2)

{

mainpanel.ChangeDefault(5);

mainpanel.proplate(mainpanel.defaultnum);

}else if(event.getSource()==num3)

{

mainpanel.ChangeDefault(7);

mainpanel.proplate(mainpanel.defaultnum);

}else if(event.getSource()==num4)

{

mainpanel.ChangeDefault(9);

mainpanel.proplate(mainpanel.defaultnum);

}else if(event.getSource()==num5)

{

mainpanel.ChangeDefault(12);

mainpanel.proplate(mainpanel.defaultnum);

}else if(event.getSource()==speed1)

{

//快速完成

mainpanel.moveSpeed=0;

}else if(event.getSource()==speed2)

{

//适中速度

mainpanel.moveSpeed=2;

}else if(event.getSource()==speed3)

{

//较慢完成

mainpanel.moveSpeed=6;

}

}

}

}

class Help1 extends JDialog{

JPanel panel1 = new JPanel();

JLabel jLabel1 = new JLabel("

 作者:徐小龙(中国石油大学)
2010年11月20日
");

JLabel jLabel2 = new JLabel();

GridLayout gridLayout1 = new GridLayout();

Help1() {

super(new MainFrame(),"程序说明",false);

setBounds(400,150,360,260);

setVisible(true);

jLabel2.setText("使用说明:
通过演示菜单来控制程序的运行,
可以选择不同的移动速度,
也可以定制盘子的数量。");

panel1.add(jLabel1,BorderLayout.NORTH);

panel1.add(jLabel2,BorderLayout.CENTER);

setResizable(false);

getContentPane().add(panel1);

}

}

class Help2 extends JDialog{

JPanel panel1 = new JPanel();

JLabel jLabel2 = new JLabel();

GridLayout gridLayout1 = new GridLayout();

Help2() {

super(new MainFrame(),"汉诺塔问题介绍",false);

setBounds(400,150,360,260);

setVisible(true);

jLabel2.setText("汉诺塔问题:
有若干个大小各不相同的盘子,
有三个桌子A、B、C,开始时,
盘子全部位于A桌上,现要将
盘子从" +

"A桌上移动到C桌上,
过程中要保证大盘子不能放到
小盘子上面,且每次只能移动一个盘子。");

panel1.add(jLabel2,BorderLayout.CENTER);

getContentPane().add(panel1);

}

}

public class HanoiDisply {

public static void main(String arg[])

{

MainFrame mainframe=new MainFrame("汉诺塔演示程序");

mainframe.addWindowListener(new WindowAdapter()

{

public void windowClosing(WindowEvent e)

{

System.exit(0);

}

});

mainframe.setResizable(false);

}

}

汉诺塔问题的三种实现

// test_project.cpp : 定义控制台应用程序的入口点。//汉诺塔问题的 // //递归实现 /*#include "stdafx.h" #include using namespace std; int count=0;//记录移动到了多少步 void Move(int n,char From,char To); void Hannoi(int n,char From, char Pass ,char To); //把圆盘从From,经过pass,移动到To int main() { int n_count=0; cout<<"请输入圆盘个数:"; cin>>n_count; Hannoi(n_count,'A','B','C'); } void Move(int n,char From,char To)

{ count++; cout<<"第"<

/*后来一位美国学者发现一种出人意料的简单方法,只要轮流进行两步操作就可以了。首先把三根柱子按顺序排成品字型,把所有的圆盘按从大到小的顺序放在柱子A上,根据圆盘的数量确定柱子的排放顺序:若n为偶数,按顺时针方向依次摆放A B C; 若n为奇数,按顺时针方向依次摆放A C B。 ()按顺时针方向把圆盘从现在的柱子移动到下一根柱子,即当n为偶数时,若圆盘在柱子A,则把它移动到B;若圆盘在柱子B,则把它移动到C;若圆盘在柱子C,则把它移动到A。 ()接着,把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上,当两根柱子都非空时,移动较小的圆盘。这一步没有明确规定移动哪个圆盘,你可能以为会有多种可能性,其实不然,可实施的行动是唯一的。 ()反复进行()()操作,最后就能按规定完成汉诺塔的移动。 所以结果非常简单,就是按照移动规则向一个方向移动金片: 如阶汉诺塔的移动:A→C,A→B,C→B,A→C,B→A,B→C,A→C 汉诺塔问题也是程序设计中的经典递归问题,下面我们将给出递归和非递归的不同实现源代码。*/ /*#include "stdafx.h" #include #include

汉诺塔c++程序

void Hanoi(int platesCount, int from, int dest, int by) { if (platesCount==1) { printf( "Move the plate from %d to %d through %d" , from, dest, by); }else { Hanoi(platesCount -1, from, by, dest); Hanoi(1, from, dest, by); Hanoi(platesCount -1, by, dest, from); } } // Advance one step to solve Hanoi void HanoiDrawer::SolveNextStep() { int platesCount , source , destination , intermediate; if(listSavedState.size()==0) { this->Hanoi(this->iPlatesCount, HanoiDrawer::SOURCE , HanoiDrawer::DESTINATION, HanoiDrawer::INTERMEDIATE); } if(listSavedState.size() % 4 != 0 ) { return; } platesCount = listSavedState.front(); listSavedState.pop_front(); source = listSavedState.front(); listSavedState.pop_front(); destination = listSavedState.front(); listSavedState.pop_front(); intermediate = listSavedState.front(); listSavedState.pop_front();

汉诺塔非递归算法C语言实现

汉诺塔非递归算法C语言实现 #include #include #define CSZL 10 #define FPZL 10 typedef struct hanoi { int n; char x,y,z; }hanoi; typedef struct Stack { hanoi *base,*top; int stacksize; }Stack; int InitStack(Stack *S) { S->base=(hanoi *)malloc(CSZL*sizeof(hanoi)); if(!S->base) return 0; S->top=S->base; S->stacksize=CSZL; return 1; } int PushStack(Stack *S,int n,char x,char y,char z) { if(S->top-S->base==S->stacksize) { S->base=(hanoi *)realloc(S->base,(S->stacksize+FPZL)*sizeof(hanoi)); if(!S->base) return 0; S->top=S->base+S->stacksize; S->stacksize+=FPZL; } S->top->n=n; S->top->x=x; S->top->y=y; S->top->z=z; S->top++; return 1; } int PopStack(Stack *S,int *n,char *x,char *y,char *z) { if(S->top==S->base)

数据结构实验报告汉诺塔

实验报告书 课程名:数据结构 题目:汉诺塔 班级: 学号: 姓名: 评语: 成绩:指导教师: 批阅时间:年月日

一、目的与要求 1)掌握栈与队列的数据类型描述及特点; 2)熟练掌握栈的顺序和链式存储存表示与基本算法的实现; 3)掌握队列的链式存储表示与基本操作算法实现; 4) 掌握栈与队列在实际问题中的应用和基本编程技巧; 4)按照实验题目要求独立正确地完成实验内容(提交程序清单及相关实验数据与运行结果); 5)认真书写实验报告,并按时提交。 二、实验内容或题目 汉诺塔问题。程序结果:给出程序执行过程中栈的变化过程与圆盘的搬动状态。 三、实验步骤与源程序 源程序: / *编译环境Visual C++6.0 */ #include "stdafx.h" #include #include void move(int h,char c,char f) { printf("%d:%c--->%c\n",h,c,f); } void hanoi(int n,char x,char y,char z) { if(n==1) move(1,x,z); else { hanoi(n-1,x,z,y); move(n,x,z); hanoi(n-1,y,x,z); } } void main(void) { int flag; do { printf(" 汉诺塔问题\n\n"); printf("[1] 开始\n"); printf("[2] 退出\n"); printf("1--2请选择:"); scanf("%d",&flag); printf("\n"); switch(flag) { case 1:

用VB设计汉诺塔动画游戏

本栏目责任编辑:谢媛媛软件设计开发Computer Knowledge and Technology 电脑知识 与技术第5卷第30期(2009年10月)用VB 设计汉诺塔动画游戏 刘德强 (无锡职业技术学院,江苏无锡214024) 摘要:汉诺塔问题是程序设计教学中关于递归调用的经典案例。该文介绍了用VB 设计汉诺塔动画游戏程序的基本过程,其中重点介绍了用VB 的自定义数据类型和图形处理技术设计游戏步点状态记录和动画效果的方法。 关键词:VB ;汉诺塔;动画 中图分类号:TP311文献标识码:A 文章编号:1009-3044(2009)30-8460-03 The Designing of Hanoi Towers Animation Game by VB LIU De-qiang (Wuxi Institute of Technology,Wuxi 214024,China) Abstract:The Hanoi Towers is a typical case of recursive calls in programming teaching.This paper introduces the basic process of design -ing Hanoi Towers animation game by VB,focuses on recording game state between two steps and designing animation by self-defined data type and graph skill in VB. Key Words:VB;Hanoi;animation 汉诺塔问题源自印度的一个古老传说,传至现代演变成了汉诺塔游戏:有A 、B 、C 三个垂直杆和若干个大小各不相同的圆片。开始时圆片全部套在A 杆上,且从下至上圆片大小依次递减。要求借助B 杆,将圆片全部移到C 杆上,每次只能移动一片,并且整个过程中三个杆上的圆片都必须保持大的在下小的在上。游戏的难度由开始时放置在A 杆上圆片的个数进行控制。 1游戏步点状态记录设计 笔者设计的汉诺塔游戏程序主要包括演示和游戏两方面的功能。演示功能实现的是根据汉诺塔问题算法预先计算出的圆片移动顺序由计算机自行对圆片进行移动;而游戏功能是指计算机通过人机交互界面根据游戏者的实时操作顺序进行圆片的移动。图1是程序运行时界面。无论是演示还是游戏,计算机执行的基本动作元素是相同的,即圆片从一个杆上移动到另一个杆上,这一过程体现在程序设计中就是在新的位置对圆片图形进行重画,它与每个杆的步点状态密切相关。 步点状态是指每完成一步操作以后,开始下一步操作之前,一个杆上 的圆片数量及各圆片的位置和大小等多个特征综合构成的状态,是多个 数据的集合。将开始时圆片数记为n ,从初始状态圆片都在A 杆上,到终 止状态n 个圆片移到C 杆上,其间每次移动圆片,各杆的步点状态都会 发生变化。游戏进程中“记”住各杆的当前步点状态,是实现不断移动圆片 的关键。以要移动A 杆上的一个圆片到B 杆为例:要判断圆片根据规则 是否可以移动及圆片移动后放置在B 杆的什么位置(y 坐标),就必须知 道当前B 杆上最上端圆片的大小和B 杆上当前圆片数量,即B 杆的当前 步点状态。综合以上分析,游戏步点状态记录是程序设计中的要点。 鉴于描述步点状态需要多个数据,且数据间相互关联并构成整体,笔 者在设计中采用了自定义数据类型的方法,数据类型名称为circles ,所含 内容和定义格式如下: Type circles counts As integer r()As integer x As integer y()As integer End Type circles 类型中,数据成员counts 用于记录杆上实际圆片数,r 用于记录各圆片的半径,x 记录各圆片圆心的x 坐标,y 记录各圆片圆心的y 坐标。因为每次游戏设置的初始圆片数是不确定的且游戏进程中各杆都可能出现多个圆片,所以数据成员r 和y 定义为动态数组。 数据类型circles 定义以后,先使用该类型定义三个实例a 、b 、c ,分别代表A 、B 、C 三个杆的步点状态。语句如下: Dim a As circles ,b As circles ,c As circles 当初始圆片数量确定后(记为n),可使用下列语句对A 杆的步点状态a 进行初始化。 投稿日期:2009-08-22 作者简介:刘德强(1965-),江苏靖江人,无锡职业技术学院讲师。 图1运行界面ISSN 1009-3044Computer Knowledge and Technology 电脑知识与技术Vol.5,No.30,October 2009,pp.8460-8462E-mail:xsjl@https://www.360docs.net/doc/9717584011.html, https://www.360docs.net/doc/9717584011.html, Tel:+86-551-569096356909648460

Java编写的扫雷小程序

J a v a编写的扫雷小程序Prepared on 21 November 2021

整个程序使用了4个类: Game 用于启动程序, 界面的布置,各种行列的算法。 ExtendButton 继承了Jbutton 用于新建button的各种属性 ShowNum 监听到某个button后,计算出此button周围有几个雷,不同的雷对应不通的图片,类得到button上应加载的图片地址 ViewReSet 此类用于新建一个窗口,用户输入自己想要的行、列、雷数,然后用新的行列雷数new 一个新的Game biaose dise1 dise2 dise3 dise4 dise5 dise6 dise7 dise8 dise lei biaoji

/**************************************************************** 运行类创建游戏主窗体 */ package class Game extends JFrame implements ActionListener{ private Container myContainer; private GridLayout myLayout; private JPanel myPanelMain; private JPanel myPanel; private JToolBar myTool; private JLabel time; private JLabel labelTime; private JLabel bombNum; private JLabel labelBombNum; private JMenuBar menuBar; private JMenu menuE, menuH; private JMenuItem menuItemCZ, menuItemSZ; private int numBomb, countTime, leaveBomb, numEnd; private int myRows, myColumns; private int xis, yis; private Timer timer; private ExtendButton[] myButton = null; etPostion(i); [i].setIcon((new ShowNum(10)).getImageIcon()); [i].setButton_num(0); [i].SetVisited(false); [i].SetStatus(false); ddMouseListener(new MouseAdapter() { public void mouseClicked(MouseEvent evt) { if (() == ) {

汉诺塔 java 程序

汉诺塔java 程序 import java.awt.*; import java.awt.event.*; import javax.swing.*; public class AutoMoveDisc extends JDialog implements ActionListener{ int amountOfDisc=3; TowerPoint [] pointA,pointB,pointC; char [] towerName; Container con; StringBuffer moveStep; JTextArea showStep; JButton bStart,bStop,bContinue,bClose; Timer time; int i=0,number=0; AutoMoveDisc(Container con){ setModal(true); setTitle("自动演示搬盘子过程"); this.con=con; moveStep=new StringBuffer(); time=new Timer(1000,this); time.setInitialDelay(10); showStep=new JTextArea(10,12); bStart=new JButton("演示"); bStop=new JButton("暂停"); bContinue=new JButton("继续"); bClose=new JButton("关闭"); bStart.addActionListener(this); bStop.addActionListener(this); bContinue.addActionListener(this); bClose.addActionListener(this); JPanel south=new JPanel(); south.setLayout(new FlowLayout()); south.add(bStart); south.add(bStop); south.add(bContinue); south.add(bClose); add(new JScrollPane(showStep),BorderLayout.CENTER); add(south,BorderLayout.SOUTH); setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); towerName=new char[3]; addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ time.stop(); setVisible(false);

汉诺塔问题实验报告

1.实验目的: 通过本实验,掌握复杂性问题的分析方法,了解汉诺塔游戏的时间复杂性和空间复杂性。 2.问题描述: 汉诺塔问题来自一个古老的传说:在世界刚被创建的时候有一座钻石宝塔(塔A),其上有64个金碟。所有碟子按从大到小的次序从塔底堆放至塔顶。紧挨着这座塔有另外两个钻石宝塔(塔B和塔C)。从世界创始之日起,婆罗门的牧师们就一直在试图把塔A 上的碟子移动到塔C上去,其间借助于塔B的帮助。每次只能移动一个碟子,任何时候都不能把一个碟子放在比它小的碟子上面。当牧师们完成任务时,世界末日也就到了。 3.算法设计思想: 对于汉诺塔问题的求解,可以通过以下三个步骤实现: (1)将塔A上的n-1个碟子借助塔C先移到塔B上。 (2)把塔A上剩下的一个碟子移到塔C上。 (3)将n-1个碟子从塔B借助于塔A移到塔C上。 4.实验步骤: 1.用c++ 或c语言设计实现汉诺塔游戏; 2.让盘子数从2 开始到7进行实验,记录程序运行时间和递 归调用次数; 3.画出盘子数n和运行时间t 、递归调用次数m的关系图, 并进行分析。 5.代码设计: Hanio.cpp #include"stdafx.h" #include #include #include void hanoi(int n,char x,char y,char z) { if(n==1) { printf("从%c->搬到%c\n",x,z); } else { hanoi(n-1,x,z,y); printf("从%c->%c搬到\n",x,z); hanoi(n-1,y,x,z); }

汉诺塔程序设计报告

数据结构 学院:信息学院 班级:计科高职13-2 姓名:曲承玉 学号:201303014044

汉诺塔程序设计报告 一、题目 汉诺塔(Towers of Hanoi)问题 二、设计要求 1、在窗口中画出初始时塔和碟子的状态。 2、可以以自动或手动两种方式搬移碟子。 3、自动搬移可以通过定时器或多线程的方法,每一次移动的时间间隔可以自定,以人眼观察比较舒服为宜,每一次的移动过程如能实现动画最好。 4、定义塔的描述类和碟子的描述类。 5、在程序中,碟子的数目及每次移动的时间间隔可以通过对话框设置(也应该有默认值)。 6、支持暂停功和继续的功能(在自动搬移过程中可以暂停,并继续)。 7、暂停后,可以将当前的状态保存(碟子和塔的组合关系)。 8、可以从7中保存的文件中读出某个状态,并继续移动。 三、问题分析 1、已知有三个塔(1、 2、3)和n个从大到小的金碟子,初始状态时n个碟子按从大到小的次序从塔1的底部堆放至顶部。 2、要求把碟子都移动到塔2(按从大到小的次序从塔2的底部堆放至顶部)。 3、每次移动一个碟子。

4、任何时候、任何一个塔上都不能把大碟子放到小碟子的上面。 5、可以借助塔3。(图1-1) 图1-1 首先考虑a杆下面的盘子而非杆上最上面的盘子,于是任务变成了: 1、将上面的63个盘子移到b杆上; 2、将a杆上剩下的盘子移到c杆上; 3、将b杆上的全部盘子移到c杆上。 将这个过程继续下去,就是要先完成移动63个盘子、62个盘子、61个盘子....1个盘的工作。 四、算法选择 汉诺塔程序设计算法的实质就是递归递归思想的运用。现将其算法简述如下: 为了更清楚地描述算法,可以定义一个函数hanoi(n,a,b,c)。该函数的功能是:将n个盘子从塔a上借助塔b移动到塔c上。这样移动n 个盘子的工作就可以按照以下过程进行: 1) hanoi(n-1,a,c,b);//将n-1个金盘由a借助c移到b 2) 将最下面的金盘从a移动到c上;

汉诺塔问题的非递归算法分析

汉诺塔递归与非递归算法研究 作者1,作者2,作者33 (陕西师范大学计算机科学学院,陕西西安 710062) 摘要: 摘要内容(包括目的、方法、结果和结论四要素) 摘要又称概要,内容提要.摘要是以提供文献内容梗概为目的,不加评论和补充解释,简明,确切地记述文献重要内容的短文.其基本要素包括研究目的,方法,结果和结论.具体地讲就是研究工作的主要对象和范围,采用的手段和方法,得出的结果和重要的结论,有时也包括具有情报价值的其它重要的信息.摘要应具有独立性和自明性,并且拥有与文献同等量的主要信息,即不阅读全文,就能获得必要的信息. 关键词:关键词1; 关键词2;关键词3;……(一般可选3~8个关键词,用中文表示,不用英文 Title 如:XIN Ming-ming , XIN Ming (1.Dept. of ****, University, City Province Zip C ode, China;2.Dept. of ****, University, City Province Zip C ode, China;3.Dept. of ****, University, City Province Zip C ode, China) Abstract: abstract(第三人称叙述,尽量使用简单句;介绍作者工作(目的、方法、结果)用过去时,简述作者结论用一般现在时) Key words: keyword1;keyword2; keyword3;……(与中文关键词对应,字母小写(缩略词除外)); 正文部分用小5号宋体字,分两栏排,其中图表宽度不超过8cm.。设置为A4页面 1 引言(一级标题四号黑体加粗) 这个问题当时老和尚和众僧们,经过计算后,预言当所有的盘子都从基柱A移到基座B上时,世界就将在一声霹雳中消灭,而梵塔、庙宇和众生也都将同归于尽。其实,不管这个传说的可信度有多大,如果考虑把64个盘子,由一个塔柱上移到另一根塔柱上,并且始终保持上小下大的顺序。假设有n个盘子,移动次数是f(n).显然f(1)=1,f(2)=3,f(3)=7,且f(k+1)=2*f(k)+1。此后不难证明f(n)=2n-1。n=64时, f(64)= 2^64-1=18446744073709551615 假如每秒钟一次,共需多长时间呢?一年大约有 31536926 秒,计算表明移完这些金片需要5800多亿年,比地球寿命还要长,事实上,世界、梵塔、庙宇和众生都早已经灰飞烟灭。 对传统的汉诺塔问题,目前还有不少的学者继续研究它的非递归解法,本文通过对递归算法的研究……. 提示:(1)可以定义问题的规模n,如盘子的数量;(2)塔柱的数量(目前有部分理论可以支撑,不妨用计算机实现)分析规模的变化与算法的复杂度比较。(3)可以对经典的汉诺塔问题条件放松、加宽,如在经典的汉诺塔问题中大盘只能在小盘下面,放松其他条件可以定义相邻两个盘子必须满足大盘只能在小盘下面。其它盘子不作要求。 2 算法设计 2.1 汉诺塔递归算法描述(二级标题小五黑体加粗) 用人类的大脑直接去解3,4或5个盘子的汉诺塔问题还可以,但是随着盘子个数的增多,问题的规模变的越来越大。这样的问题就难以完成,更不用说吧问题抽象成循环的机器操作。所以类似的问题可用递归算法来求解。下面n个盘的汉

汉诺塔 面向对象课程设计

数据库课程设计报告------------题目:汉诺塔 学院名称:计算机学院 专业名称:计算机科学与技术 班级:计算机08-08班 学号:0804010807 姓名:田昊 指导教师:孙冬璞 起始时间:2011年1月5日-------2011年1月9日

摘要 汉诺塔(又称河内塔)问题是一个古典的数学问题,是一个用递归方法解题的典型例子。问题是这样的:开天辟地的神勃拉玛在一个庙里留下了三根金刚石的棒,第一根上面套着64个圆的金片,最大的一个在底下,其余一个比一个小,依次叠上去,庙里的众僧不倦地把它们一个个地从这根棒搬到另一根棒上,规定可利用中间的一根棒作为帮助,但每次只能搬一个,而且大的不能放在小的上面。 利用计算机图形学进行汉诺塔演示程序设计,是利用C语言绘图函数实现汉诺塔的递归算法图形界面演示过程。通过C语言实现图形学的绘图,程序控制,以及区域填充,并根据汉诺塔的算法原理实现大小不同的盘子移动的全过程演示。 1 需求分析 1.1 需求概述 汉诺塔演示程序设计是计算机图形学中图形变换的内容之一。而图形学中的图形变换的概念是由简单图形生成复杂图形,可用二维图形表示三维形体,甚至可以对静态图形经过快速变换而获得图形的动态显示效果。其任务是研究各点坐标之间的变化规律。而本次课程设计就是利用C语言以及图形函数实现汉诺塔的递归算法来进行其盘块移动的全过程显示。在TC环境中要实现这样的功能,就要牵涉到图形设备接口的知识。Windows图形设备接口是为与设备无关的图形设计的,是Windows系统的重要组成部分,负责系统与用户或绘图程序之间的信息交换,并控制在输出设备上显示图形或文字。应用程序必须通知图形设备接口来加载特定的设备驱动,一旦驱动得以加载,就可以准备应用设备进行相关的操作这些任务都要通过创建和维护设备描述表来完成。在实现汉诺塔演示程序设计时,是利用坐标系统而得到的,而在Windows应用程序中有两种坐标系统:设备坐标系统和逻辑坐标系统。其中设备坐标系统中又有三种相互独立的坐标系统:屏幕坐标系统、窗口坐标系统和用户区坐标系统。这些坐标系统均以像素点来表示度量的单位。屏幕坐标系统使用整个屏幕作为坐标区域,原点为屏幕原点。窗口坐标系统使用了边界在内的应用程序的窗口作为坐标区域。窗口边界的左上角是坐标系统的原点。用户坐标系统是最经常使用的坐标系统。用户区是窗口工作区,不包括窗口边界、菜单条及滚动条等。用户一般只需操作应用程序的用户区,因此用户区坐标系统对大多数应用程序都是适用的。

汉诺塔问题与递归思想教学设计

一、教学思想(包括教学背景、教学目标) 1、教学背景 本课程“递归算法”,属于《数据结构与算法》课程中“栈和队列”章节的重点和难点。数据结构与算法已经广泛应用于各行各业的数据存储和信息处理中,与人们的社会生活密不可分。该课程是计算机类相关专业核心骨干课程,处于计算机学科的核心地位,具有承上启下的作用。不仅成为全国高校计算机类硕士研究生入学的统考科目,还是各企业招聘信息类员工入职笔试的必考科目。数据结构与算法课程面向计算机科学与技术、软件工程等计算机类学生,属于专业基础课。 2、教学大纲 通过本课程的学习,主要培养学生以下几个方面的能力: 1)理解递归的算法; 2)掌握递归算法的实现要素; 3)掌握数值与非数值型递归的实现方法。 根据学生在学习基础和能力方面的差异性,将整个课程教学目标分成三个水平:合格水平(符合课标的最低要求),中等以上水平(符合课标的基本要求),优秀水平(符合或超出课标提出的最高要求)。具体如下表:

二、课程设计思路(包括教学方法、手段) “递归算法”课程以故事引入、案例驱动法、示范模仿、启发式等多元化教学方法,设计课程内容。具体的课堂内容如下所示:

1 1 2 3 3 7 4 15 5 31 count = 2n-1 思考:若移动速度为1个/秒,则需要 (264-1)/365/24/3600 >= 5849亿年。 四、总结和思考 总结: 对于阶乘这类数值型问题,可以表达成数学公式,然后从相应的公式入手推导,解决这类问题的递归定义,同时确定这个问题的边界条件,找到结束递归的条件。 对于汉诺塔这类非数值型问题,虽然很难找到数学公式表达,但可将问题进行分解,问题规模逐渐缩小,直至最小规模有直接解。 思考: 数值型问题:斐波那契数列的递归设计。 非数值型问题:八皇后问题的递归设计。阐述总结知识拓展 三、教学特色(总结教学特色和效果) 递归算法课程主要讨论递归设计的思想和实现。从阶乘实例入手,由浅入深,层层深入介绍了递归的设计要点和算法的实现。从汉诺塔问题,通过“边提问,边思考”的方式逐层深入地给出算法的分析和设计过程。通过故事引入、案例导入、实例演示、PPT展示、实现效果等“多元化教学方式”,努力扩展课堂教学主战场。加上逐步引导、问题驱动,启发学生对算法的理解,并用实例演示展示算法的分析过程,在编译环境下实现该算法,加深对算法实现过程的认识。 1、知识点的引入使用故事诱导法讲授 通过“老和尚讲故事”引入函数的递归调用,并通过“世界末日问题” 故事引入非数值型问题的递归分析,激发学习积极性,挖掘学生潜能。

java小程序设计

课程设计报告 设计题目:用Java编的计算器 院系 班级 设计者 学号 指导教师 设计时间

前言: 通过上课学习了java程序设计的基本原理和模式,这次又以java语言为基本结合其图形应用界面来设计一个包括加、减、乘、除。还有带括号以及带负号、小数运算的计算程序。 系统功能和使用说明: 一.硬件环境: 本系统适用于现应用各种类型的计算机,内存容量为128MB以上,不必配备的外部附加设备。二.软件环境: 本系统的设计采用的是JAVA语言,应在JDK 5.0或者其更高版软件环境下本使用。 三.系统流程图: 1.下图是本程序的运行后的界面,其标注是此组件在程序中的名字 2.系统流程图中各个模块的功能说明: 本程序一共包括:构造方法A5i13w(),setup(), windowClosing(), actionPerformed(), appendchar(), countall(), counting(), Iscountnum()和一个windowcloser类。 (1). A5i13w()是构造方法,在程序创建其对象时就调用,初始化次程序的事件的监听机制。 (2). setup()是我定义的方法,是用来初始化程序的图形应用界面,由A5i13w()来调用。 (3). windowClosing()是用来响应用户的关闭功能。 (4). actionPerformed()是用来处理每个事件的响应的方法 (5). appendchar()方法的作用是在用户产生事件后向Textshow追加产生此事件的字符串 (6).countall()的意义是在用户按“=”号后,从最里层括号向最外层逐层把括号里的内容传递给counting()方法,并负责对括号本身是否符合数学语法要求进行检验。 (7).counting()方法的作用是首先对无括号的数学表达式有关的数学计算符号进行调整,并检验所有的数学符号,如发现错误的数学符号立即在Labelnow中显示出来。

汉诺塔问题非递归算法详解

Make By Mr.Cai 思路介绍: 首先,可证明,当盘子的个数为n 时,移动的次数应等于2^n - 1。 然后,把三根桩子按一定顺序排成品字型(如:C ..B .A ),再把所有的圆盘按至上而下是从小到大的顺序放在桩子A 上。 接着,根据圆盘的数量确定桩子的排放顺序: 若n 为偶数,按顺时针方向依次摆放C ..B .A ; 若n 为奇数,按顺时针方向依次摆放B ..C .A 。 最后,进行以下步骤即可: (1)首先,按顺时针方向把圆盘1从现在的桩子移动到下一根桩子,即当n 为偶数时,若圆盘1在桩子A ,则把它移动到B ;若圆盘1在桩子B ,则把它移动到C ;若圆盘1在桩子C ,则把它移动到A 。 (2)接着,把另外两根桩子上可以移动的圆盘移动到新的桩子上。 即把非空桩子上的圆盘移动到空桩子上,当两根桩子都非空时,移动较小的圆盘。 (3)重复(1)、(2)操作直至移动次数为2^n - 1。 #include #include using namespace std; #define Cap 64 class Stake //表示每桩子上的情况 { public: Stake(int name,int n) { this->name=name; top=0; s[top]=n+1;/*假设桩子最底部有第n+1个盘子,即s[0]=n+1,这样方便下面进行操作*/ } int Top()//获取栈顶元素 { return s[top];//栈顶 } int Pop()//出栈 { return s[top--];

} void Push(int top)//进栈 { s[++this->top]=top; } void setNext(Stake *p) { next=p; } Stake *getNext()//获取下一个对象的地址 { return next; } int getName()//获取当前桩子的编号 { return name; } private: int s[Cap+1];//表示每根桩子放盘子的最大容量 int top,name; Stake *next; }; void main() { int n; void hanoi(int,int,int,int); cout<<"请输入盘子的数量:"; cin>>n; if(n<1) cout<<"输入的盘子数量错误!!!"<

Java图形用户界面编程练习

实验八Java图形用户界面编程练习 实验目的 1、掌握 Java 的 GUI 设计技术 2、掌握 AWT 和 Swing 的应用技巧 实验要求 1、编写一个程序学习使用处理ActiongEvent事件 2、编写一个程序学习使用布局类 实验内容 1.猜数字游戏 实验目的:练习图形用户界面编程,学习处理ActionEvent事件。 实用要求: 要求程序中要有2个按钮buttonGetNumber和buttonNumber,用户单击buttonGetNumber 按钮可以得到一个随机数,然后在文本框中输入猜测数字,再单击buttonNumber按钮,程序根据用户的猜测给出提示信息。 运行效果示例: 程序模板:按模板要求,将【代码】替换为Java程序代码。 GuessExample.java import java.awt.*;

import java.awt.event.*; import java.applet.*; public class GuessExample extends Applet implements ActionListener { int number; TextField inputNumber; Label feedBack; Button buttonGetNumber,buttonEnter; public void init() { buttonGetNumber=new Button("得到一个随机数"); feedBack=new Label ("无反馈信息",Label.CENTER); feedBack.setBackground(Color.green); inputNumber=new TextField("0",5); buttonEnter=new Button("确定"); 【代码1】//按钮buttonEnter增加ActionEvent事件监视器,监视器为当前Java Applet。 【代码2】//按钮buttonGetNumber增加ActionEvent事件监视器,监视器为当前Java Applet。 add(new Label("获取1-100之间的随机数:")); add(buttonGetNumber); add(new Label("输入您的猜测:")); add(inputNumber); add(new Label("单击确定按钮:")); add(buttonEnter); add(new Label("反馈信息:")); add(feedBack); } public void actionPerformed(ActionEvent e) { if(【代码3】) //判断事件源是否是buttonGetNumber。 { number=(int)(Math.random()*100)+1; } else if(【代码4】) //判断事件源是否是buttonEnter。 { int guess=0; try { guess=Integer.parseInt(【代码5】); //返回inputNumber中的文本。 if(guess==number) { 【代码6】//feedBack设置提示文本:"猜对了!"。 }

汉诺塔程序实验报告

实验题目: Hanoi 塔问题 一、问题描述: 假设有三个分别命名为 A , B 和C 的塔座,在塔座 B 上插有n 个直径大小各不相同、从小到 大编号为1, 2,…,n 的圆盘。现要求将塔座 B 上的n 个圆盘移至塔座 A 上并仍按同样顺序 叠排,圆盘移动时必须遵守以下规则: (1 )每次只能移动一个圆盘; (2)圆盘可以插在 A , B 和C 中任一塔上; ( 3)任何时刻都不能将一个较大的圆盘压在较小的圆盘之上。 要求: 用程序模拟上述问题解决办法,并输出移动的总次数, 圆盘的个数从键盘输入; 并想 办法计算出程序运行的时间。 二、 算法思路: 1 、建立数学模型: 这个问题可用递归法解决,并用数学归纳法又个别得出普遍解法: 假设塔座B 上有3个圆盘移动到塔座 A 上: (1) "将塔座B 上2个圆盘借助塔座 A 移动到塔座C 上; (2) "将塔座B 上1个圆盘移动到塔座 A 上; (3) "将塔座C 上2个圆盘借助塔座 B 移动到塔座A 上。 其中第 2步可以直接实现。第 1步又可用递归方法分解为: 1.1"将塔座B 上1个圆盘从塔座 1.2"将塔座B 上1个圆盘从塔座 1.3"将塔座A 上1个圆盘从塔座 第 3 步可以分解为: 3.1将塔座C 上1个圆盘从塔座 3.2将塔座C 上1个圆盘从塔座 3.3将塔座B 上1个圆盘从塔座 综上所述:可得到移动 3 个圆盘的步骤为 B->A,B->C, A->C, B->A, C->B, C->A, B->A, 2、算法设计: 将n 个圆盘由B 依次移到A , C 作为辅助塔座。当 n=1时,可以直接完成。否则,将塔 座B 顶上的n-1个圆盘借助塔座 A 移动到塔座C 上;然后将圆盘B 上第n 个圆盘移到塔 座A 上;最后将塔座 C 上的n-1个圆盘移到塔座 A 上,并用塔座B 作为辅助塔座。 三、原程序 #include #include #include int times = 0; void move(char a, char b) { printf("%c > %c \n", a,b); } void hno(int n,char a , char b, char c) { if (n==1) { move(a,c); times ++; } X 移动到塔座 A ; X 移动到塔座 C ; Z 移动到塔座 C 。 Y 移动到塔座 Y 移动到塔座 X 移动到塔座 B ; A ;

汉诺塔程序解读

hanoi塔程序如下: main() {hanoi(3,'A','B','C'); } hanoi(n,a,b,c) int n; char a,b,c; {if (n==1) printf("%c-->%c\n",a,c); else {hanoi (n-1,a,c,b); printf ("%c-->%c\n",a,c); hanoi (n-1,b,a,c);} } 运行结果: A-->C A-->B C-->B A-->C B-->A B-->C A-->C 问题: hanoi(n,a,b,c) int n; char a,b,c; {if (n==1) printf("%c-->%c\n",a,c); else {hanoi (n-1,a,c,b); printf ("%c-->%c\n",a,c); hanoi (n-1,b,a,c);} } 我给你详细解释下这个程序中的代码吧。我也是刚学,希望对你有用。可能有些不好之处,还希望谅解。 先说下这个问题的整体思想: 1,如果只有1个盘,那么就直接把这个盘从A移动到C上。

2,如果存在两个盘,那么先把第一个盘移动到B上,在把最下面一个盘移动到C上,在把B上的盘移动到C上。 3,这样,我们可以得出一个结论,如果存在N个盘,可以先把上面N-1个盘通过C 移动到B上,然后把第N个盘移动到C上,再把B上的N个盘通过A 移动到C上。 if (n==1) printf("%c-->%c\n",a,c); 这一句,表示只有1个盘子的时候,那么就是把第一个盘子直接移到第三个盘子上。 else {hanoi (n-1,a,c,b); 如果超过一个盘字,则需要先把N-1个盘子通过C 移动到B上。 printf ("%c-->%c\n",a,c); 把剩下的第N个盘,从A移动到C上。 hanoi (n-1,b,a,c);} 再把剩下的在B上的N-1个盘,通过A移动到C上。 这属于一个递归算法。 现在,N=3。 我们看下程序怎么运行的。 else {hanoi (n-1,a,c,b); printf ("%c-->%c\n",a,c); hanoi (n-1,b,a,c);} N=3,也就是开始程序会执行 hanoi (2,a,c,b);这句语句。 再看,2还是大于1,所以 程序会继续运行。注意,这里,为hanoi (2,a,c,b); C和B 换了位置。 hanoi (2,a,c,b); 我们把数字代入,得出。 根据N=2,C和B 互换。以及下面的代码,得出 ````````````````````````````````````````````````

相关文档
最新文档