java汉诺塔演示

最新推荐文章于 2022-09-13 14:02:55 发布
最新推荐文章于 2022-09-13 14:02:55 发布
阅读量172 收藏
点赞数
分类专栏： java 概述 文章标签： java intellij-idea
原文链接：java.org
版权
概述 同时被 2 个专栏收录
26 篇文章 0 订阅
订阅专栏
java
17 篇文章 0 订阅
订阅专栏 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package hannoi;

/**
 *
 * @author Administrator
 */
import java.io.*;
import java.awt.*;
public class Disk extends Button
{
    int number;
    boolean 上方有盘=false;
    public Disk(int number,HannoiTower con)
    {
        this.number=number;
        setBackground(Color.blue);
        addMouseMotionListener(con);
        addMouseListener(con);
    }
    public boolean get上方有盘()
    {
        return 上方有盘;
    }
    public void set上方有盘(boolean b)
    {
        上方有盘=b;
    }
    public int getNumber()
    {
        return number;
    }

}
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package hannoi;

/**
 *
 * @author Administrator
 */
import java.awt.*;
public class TowerPoint 
{
    int x,y;
    boolean 有盘子;
    Disk 盘子=null;
    HannoiTower con=null;
    public TowerPoint(int x,int y,boolean boo)
    {
        this.x=x;
        this.y=y;
        有盘子=boo;
    }
    public boolean 是否有盘子()
    {
        return 有盘子;
    }
    public void set有盘子(boolean boo)
    {
        有盘子=boo;
    }
    public int getX()
    {
        return x;
    }
    public int getY()
    {
        return y;
    }
    public void 放置盘子(Disk 盘子,HannoiTower con)
    {
        this.con=con;
        con.setLayout(null);
        this.盘子=盘子;
        con.add(盘子);
        int w=盘子.getBounds().width;
        int h=盘子.getBounds().height;
        盘子.setBounds(x-w/2,y-h/2,w,h);
        有盘子=true;
        con.validate();
    }
    public Disk 获取盘子()
    {
        return 盘子;
    }

}
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package hannoi;

/**
 *
 * @author Administrator
 */
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class HannoiTower extends JPanel implements MouseListener,MouseMotionListener
{
   TowerPoint point[];                                          
   int x,y;                                                     
   boolean move=false;                                         
   Disk   盘子[];                                              
   int startX,startY;                                          
   int startI ;                                                
   int 盘子数目=0;
   int width,height;                                           
   char towerName[]={'A','B','C'};                            
   TextArea 信息条=null;                                      

   public  HannoiTower(int number,int w,int h,char[] name,TextArea text)
   {
        towerName=name;
        盘子数目=number;
        width=w;
        height=h;
        信息条=text;
        setLayout(null);
        addMouseListener(this);
        addMouseMotionListener(this);
        盘子= new Disk[盘子数目];
        point=new TowerPoint[3*盘子数目];                         
         int space=20;  
        for(int i=0;i<盘子数目;i++)                               
          {
            point[i]=new TowerPoint(40+width,100+space,false); 
            space=space+height;
          }
        space=20;
        for(int i=盘子数目;i<2*盘子数目;i++)                        
          {
            point[i]=new TowerPoint(160+width,100+space,false);
            space=space+height;
          }
        space=20;
        for(int i=2*盘子数目;i<3*盘子数目;i++)                     
          {
            point[i]=new TowerPoint(280+width,100+space,false);
            space=space+height;
          }
       int tempWidth=width;                                      
       int sub=(int)(tempWidth*0.2);
       for(int i=盘子数目-1;i>=0;i--)                            
          {
             盘子[i]=new Disk(i,this);
             盘子[i].setSize(tempWidth,height);                   
             tempWidth=tempWidth-sub;
          }
        for(int i=0;i<盘子数目;i++)                             
          {
            point[i].放置盘子(盘子[i],this);
            if(i>=1)
            盘子[i].set上方有盘(true); 
          }
    }
  public void paintComponent(Graphics g)                     
   {
     super.paintComponent(g);
     g.drawLine(point[0].getX(),point[0].getY(),
                point[盘子数目-1].getX(),point[盘子数目-1].getY());     
     g.drawLine(point[盘子数目].getX(),point[盘子数目].getY(),
                point[2*盘子数目-1].getX(),point[2*盘子数目-1].getY()); 
     g.drawLine(point[2*盘子数目].getX(),point[2*盘子数目].getY(),
                point[3*盘子数目-1].getX(),point[3*盘子数目-1].getY()); 
     g.drawLine(point[盘子数目-1].getX()-width,point[盘子数目-1].getY(),
               point[3*盘子数目-1].getX()+width,point[3*盘子数目-1].getY()); 
     int leftx=point[盘子数目-1].getX()-width;
     int lefty=point[盘子数目-1].getY();
     int w=(point[3*盘子数目-1].getX()+width)-(point[盘子数目-1].getX()-width);
     int h=height/2;
     g.setColor(Color.orange);
     g.fillRect(leftx,lefty,w,h);
     
     g.setColor(Color.red);
     int size=4;
     for(int i=0;i<3*盘子数目;i++)                                    
       {
         g.fillOval(point[i].getX()-size/2,point[i].getY()-size/2,size,size);
       }
     g.drawString(""+towerName[0]+"塔",point[盘子数目-1].getX(),point[盘子数目-1].getY()+30);
     g.drawString(""+towerName[1]+"塔",point[2*盘子数目-1].getX(),point[盘子数目-1].getY()+30);
     g.drawString(""+towerName[2]+"塔",point[3*盘子数目-1].getX(),point[盘子数目-1].getY()+30);
     
     g.drawString("将全部盘子从"+towerName[0]+"塔搬运到"+towerName[1]+"塔或"+towerName[2]+"塔",
                  point[盘子数目-1].getX(),point[盘子数目-1].getY()+80);        
   } 
  public void mousePressed(MouseEvent e)
  { 
    Disk  盘子=null;
    Rectangle rect=null;
    if(e.getSource()==this)                                 
        move=false;
    if(move==false)
      if(e.getSource() instanceof Disk)
       {
         盘子=(Disk)e.getSource();                          
         startX=盘子.getBounds().x;                         
         startY=盘子.getBounds().y;     
         
          rect=盘子.getBounds();
          for(int i=0;i<3*盘子数目;i++)   
            {
               int x=point[i].getX();
               int y=point[i].getY();
                  if(rect.contains(x,y))
                   {                   
                     startI=i;                            
                     break;
                   }
            }
       }
  } 
 public void mouseMoved(MouseEvent e)
  { 
  }
 public void mouseDragged(MouseEvent e)
  {
 
    Disk disk=null;
       if(e.getSource() instanceof Disk)
         {
           disk=(Disk)e.getSource();                        
           move=true; 
           
           e=SwingUtilities.convertMouseEvent(disk,e,this); 
         }
    
       if(e.getSource()==this)
        {
          if(move&&disk!=null)
           {
            x=e.getX(); 
            y=e.getY();
            if(disk.get上方有盘()==false)
               disk.setLocation(x-disk.getWidth()/2,y-disk.getHeight()/2);
           }
        }
 }
 public void mouseReleased(MouseEvent e)
  { 
    Disk disk=null;
    move=false;
    Rectangle rect=null;
    if(e.getSource() instanceof Disk)
      {
        disk=(Disk)e.getSource();                            
        rect=disk.getBounds();
         
        e=SwingUtilities.convertMouseEvent(disk,e,this);    
      }
    if(e.getSource()==this)
     {
        boolean containTowerPoint=false;
        int x=0,y=0;
        int endI=0;
        if(disk!=null)
         { 
          for(int i=0;i<3*盘子数目;i++)
            {
                x=point[i].getX();
                y=point[i].getY();
                if(rect.contains(x,y))
                   { 
                     containTowerPoint=true;
                     endI=i;
                     break;
                  }
            }
         }
        if(disk!=null&&containTowerPoint)
         {
         
           if(point[endI].是否有盘子()==true)        
             { 
               disk.setLocation(startX,startY);                        
             } 
          else
             {
 
                if(endI==盘子数目-1||endI==2*盘子数目-1||endI==3*盘子数目-1)  
                 { 
                  point[endI].放置盘子(disk,this);                       
                  
                  if(startI!=盘子数目-1&&startI!=2*盘子数目-1&&startI!=3*盘子数目-1)
                    {
                     (point[startI+1].获取盘子()).set上方有盘(false);
                     point[startI].set有盘子(false);     
                    }
                  else
                    {
                       point[startI].set有盘子(false);  
                    } 
                 } 
                else 
                 { 
                   if(point[endI+1].是否有盘子()==true)
                    {
                      Disk tempDisk=point[endI+1].获取盘子();
                      if((tempDisk.getNumber()-disk.getNumber())>=1)
                       {
                        point[endI].放置盘子(disk,this);                
                         if(startI!=盘子数目-1&&startI!=2*盘子数目-1&&startI!=3*盘子数目-1)
                          {
                            (point[startI+1].获取盘子()).set上方有盘(false);
                             point[startI].set有盘子(false); 
                             tempDisk.set上方有盘(true);   
                          }
                         else
                          {
                             point[startI].set有盘子(false); 
                             tempDisk.set上方有盘(true); 
                          } 
                       }
                      else
                       {
                         disk.setLocation(startX,startY); 
                       }
                    }
                   else
                    {
                      disk.setLocation(startX,startY);                   
                    }
                 } 
            }
        
                
        }
     if(disk!=null&&!containTowerPoint)        
        {        
          disk.setLocation(startX,startY);
        }
     } 
  }
 public void mouseEntered(MouseEvent e)
  {
  }
 public void mouseExited(MouseEvent e)
  { 
  }
 public void mouseClicked(MouseEvent e)
  { 
  }
 
 public void 自动演示搬运盘子(int 盘子数,char one,char two,char three)
  {
     if(盘子数==1)
       {
         信息条.append(""+one+" 到: "+three+"塔\n");
         Disk disk=在塔中获取最上面的盘子(one);
         int startI=在塔中获取最上面盘子的位置(one);
         int endI=在塔中获取最上面盘子的上方位置(three);                 
         if(disk!=null)
           {
             point[endI].放置盘子(disk,this);
             point[startI].set有盘子(false);
              try{
                  Thread.sleep(1000);                       
                 }
              catch(Exception ee)
                 {
                 }
           }
        }
      else
        {
          自动演示搬运盘子(盘子数-1,one,three,two);
	  信息条.append(""+one+" 到: "+three+"塔\n");
          Disk disk=在塔中获取最上面的盘子(one);
          int startI=在塔中获取最上面盘子的位置(one);
          int endI=在塔中获取最上面盘子的上方位置(three);                 
          if(disk!=null)
            {
             point[endI].放置盘子(disk,this);
             point[startI].set有盘子(false);
             try {
                  Thread.sleep(1000);                       
                 }
              catch(Exception ee)
                 {
                 }
            } 
	  自动演示搬运盘子(盘子数-1,two,one,three);
        }
  }
 public Disk 在塔中获取最上面的盘子(char 塔名)
  {
    Disk disk=null;
    if(塔名==towerName[0])
      {
         for(int i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
     if(塔名==towerName[1])
      {
         for(int i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
      if(塔名==towerName[2])
      {
         for(int i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 disk=point[i].获取盘子();
                 break;
               }
           }  
      }
   return disk;
  } 
 public int 在塔中获取最上面盘子的上方位置(char 塔名)
  {
    int position=0;
    if(塔名==towerName[0])
      {  
         int i=0;
         for(i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);
                 break;
               }
           } 
         if(i==盘子数目)
           {
             position=盘子数目-1;
           } 
      }
     if(塔名==towerName[1])
      {  
          int i=0;
         for(i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);
                 break;
               }
           } 
          if(i==2*盘子数目)
           {
             position=2*盘子数目-1;
           }  
      }
      if(塔名==towerName[2])
      {
         int i=0;
         for(i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=Math.max(i-1,0);
                 break;
               }
           }  
          if(i==3*盘子数目)
           {
             position=3*盘子数目-1;
           }  
      }
    return position;
  } 
  public int 在塔中获取最上面盘子的位置(char 塔名)
  {
    int position=0;
    if(塔名==towerName[0])
      {  
         int i=0;
         for(i=0;i<盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           } 
         if(i==盘子数目)
           {
             position=盘子数目-1;
           } 
      }
     if(塔名==towerName[1])
      {  
          int i=0;
         for(i=盘子数目;i<2*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           } 
          if(i==2*盘子数目)
           {
             position=2*盘子数目-1;
           }  
      }
      if(塔名==towerName[2])
      {
         int i=0;
         for(i=2*盘子数目;i<3*盘子数目;i++)
           {
             if(point[i].是否有盘子()==true)
               {
                 position=i;
                 break;
               }
           }  
          if(i==3*盘子数目)
           {
             position=3*盘子数目-1;
           }  
      }
    return position;
  } 
}
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package hannoi;

/**
 *
 * @author Administrator
 */
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Tower extends Frame implements ActionListener,Runnable
{
    HannoiTower tower=null;
    Button renew,auto=null;
    char towerName[]={'A','B','C'};
    int 盘子数目,盘宽,盘高;
    Thread thread;
    TextArea 信息条=null;
    public Tower()
    {
        thread=new Thread(this);
        盘子数目=5;
        盘宽=80;
        盘高=18;
        信息条=new TextArea(12,12);
        信息条.setText(null);
        tower=new HannoiTower(盘子数目,盘宽,盘高,towerName,信息条);
        renew=new Button("重新开始");
        auto=new Button("自动演示搬盘子");
        renew.addActionListener(this);
        auto.addActionListener(this);
        add(tower,BorderLayout.CENTER);
        add(renew,BorderLayout.SOUTH);
        add(auto,BorderLayout.NORTH);
        add(信息条,BorderLayout.EAST);
        addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);
            }
        });
        setVisible(true);
        setBounds(60,20,670,540);
        validate();
    }
   public void actionPerformed(ActionEvent e)
   {
       if(e.getSource()==renew)
       {
           if(!(thread.isAlive()))
           {
               this.remove(tower);
               信息条.setText(null);
               tower=new HannoiTower(盘子数目,盘宽,盘高,towerName,信息条);
               add(tower,BorderLayout.CENTER);
               validate();
           }
           else
           {
               
           }
       }
       if(e.getSource()==auto)
       {
           if(!(thread.isAlive()))
           {
               thread=new Thread(this);
           }
           try
           {
               thread.start();
           }
           catch(Exception eee)
           {
               
           }
       }
   }
   public void run()
   {
       this.remove(tower);
       信息条.setText(null);
       tower=new HannoiTower(盘子数目,盘宽,盘高,towerName,信息条);
       add(tower,BorderLayout.CENTER);
       validate();
       tower.自动演示搬运盘子(盘子数目,towerName[0],towerName[1],towerName[2]);
   }
   public static void main(String args[])
   {
       new Tower();
   }
}

automan_huyaoge
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 汉诺塔的演示程序
谢泽谆的专栏
09-12 1344
import javax.swing.JOptionPane;import javax.swing.*;import java.awt.*;import java.awt.Graphics;public class Hanoi extends JFrame{        static int n=Integer.parseInt(JOptionPane.showInputDialog("Ente
用java语言实现汉诺塔的演示程序
hengshan的专栏
11-13 5704
利用传统的递规算法实现汉诺塔的演示程序。源代码：/** *本程序完成的功能是利用汉递规算法实现汉诺塔的动态演示程序 */import javax.swing.*;import java.awt.geom.*;import java.awt.event.*;import java.awt.*;public class Hanio extends JApplet implements ActionLi
JAVA实现汉诺塔自动演示
11-25
用java写的Applet小程序，可以实现汉诺塔，并可以自动演示。
基于Java实现的Hannoi汉诺塔自动演示程序
qq_38474871的博客
07-18 937
1 设计要求设计GUI界面的Hannoi塔。汉诺塔中有三个座，名字分别为A，B，C。初始状态时A塔上有3个大小不等的盘子，这些盘子从座底到座顶按着大小顺序依次摆放在A座上。用户可以用鼠标选中盘子，然后通过拖动鼠标来移动盘子。释放鼠标来放置该盘子。程序要求用户在移动盘子的过程中，不允许吧大盘子放置在小盘子的上面，用户最终要完成的是把A座上的全部盘子移动到B座...
java 汉诺塔实现自动演示
weixin_34392843的博客
07-10 224
1、增加计时功能，显示用户完成移动盘子所花费的时间 2、用户可以设置最大和最小盘子的大小 3、用户可以选择播放和暂停背景音乐 4、用户可以设置盘子的数目 5、用户可以设置盘子的颜色以及背景的颜色 6、用户可以将自动移动盘子的文本信息保存到文件 在原有代码上增加，增加的新代码要注释 import java.awt.*; import java.awt.event.*; import jav...
java实现汉诺塔演示及手动操作汉诺塔
05-31
汉诺塔是一个经典的递归问题，...通过阅读代码，我们可以看到如何将理论的汉诺塔算法与Java GUI编程结合在一起，实现了一个交互式的汉诺塔游戏。这对于学习Java编程、递归算法以及图形用户界面设计都是很好的实践案例。
java版汉诺塔演示
04-23
下面将详细阐述这个Java版汉诺塔演示程序的相关知识点。 1. **汉诺塔问题描述** 汉诺塔问题由三根柱子（A、B、C）和若干个大小不一的圆盘组成。所有圆盘开始都在A柱上，按照大小顺序自上而下排列。目标是将所有...
Java applet汉诺塔演示程序
10-23
一个使用java applet 技术实现的汉诺塔演示程序，程序参考其他程序。功能有（内含报告）： 1.随时更改圆盘数； 2.演示速度可更改； 3.演示时间统计； 4.控制按钮的逻辑完备； 5.显示演示过程（文本显示）
hannuo.rar_汉诺塔_汉诺塔演示
09-21
在实际编程中，汉诺塔问题可以使用多种编程语言实现，如Python、Java、C++等。这些实现通常涉及递归函数，如以下Python示例： ```python def hanoi(n, source, auxiliary, target): if n > 0: # 移动n-1个圆盘从...
JAVA 汉诺塔自动演示
12-19
JAVA 汉诺塔自动演示是指使用JAVA编程语言实现汉诺塔问题的自动化演示程序。 在JAVA中实现汉诺塔自动演示，主要涉及以下几个知识点： 1. **递归**：汉诺塔问题的解决方案是基于递归算法的。递归函数通常包含两个...
完美的汉诺塔程序源代码（Java）
10-05
这是一个很好的Java编写的汉诺塔演示程序。代码清晰，并且有注释。
java实现汉诺塔小游戏
03-10
用java实现的汉诺塔游戏，含源代码和可执行exe文件，供初学者参考学习
java swing汉诺塔窗体小游戏
02-06
用java swing写的一个简单的汉诺塔窗体小游戏，代码较为简单，有详细的注释，点击即可运行，适合新手学习的小项目
用java实现汉诺塔
t253389的博客
12-20 5230
（一）汉诺塔的规则 1、有三根相邻的柱子，标号为A,B,C。 2、A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘。 3、现在把所有盘子一个一个移动到柱子B上，并且每次移动同一根柱子上都不能出现大盘子在小盘子上方。 （二）题解步骤 1、当n=1时； 将1号从A移动到C即可 2、当n=2时； 第一步：将1号从A移动到B 第二步：将2号从A移动到C 第三步：将1号从B移动到C 3、当n=3时； 第一步：将1号从A移动到C 第二步：将2号从A移动到B 第三步：将1号从.
汉诺塔算法使用Java可视化组件Swing演示
XuXuemin的专栏
04-16 1230
这是使用Java实现的汉诺塔的演示程序，采用javax.swing可视化库编写的客户端，算法是经典的汉诺塔算法。该算法思想其实是一个逆向思维的过程。 系统介绍 功能包括手动和自动，可选饼个数。鄙人界面技术有限，未实现渐变动画效果。 功能截图 源码地址：https://github.com/duoyle/hanoi ...
基于JavaSwing开发汉诺塔游戏 将盘子从A塔搬运B塔和C塔（自动演示 重新开始） 课程设计 大作业
m0_37916936的博客
09-13 1079
基于JavaSwing开发将盘子从A塔搬运B塔和C塔（自动演示 重新开始）： （大作业）基于JavaSwing开发将盘子从A塔搬运B塔和C塔（自动演示 重新开始）： （大作业）基于JavaSwing开发将盘子从A塔搬运B塔和C塔（自动演示 重新开始）： （大作业）基于JavaSwing开发将盘子从A塔搬运B塔和C塔（自动演示 重新开始）： （大作业）开发工具： MyEclipse+Jdk1.6。开发工具： MyEclipse+Jdk1.6。开发工具： MyEclipse+Jdk1.6。
汉诺塔 Java 简单实现小程序
steven_cici的博客
10-07 517
算法描述： 汉诺塔主要是有三个塔座X，Y，Z，要求将三个大小不同，依小到大编号为1，2…n的圆盘从A移动到塔座Z上，要求 （1）：每次只能移动一个圆盘 （2）：圆盘可以插到X，Y，Z中任一塔座上 （3）：任何时候不能将一个较大的圆盘压在较小的圆盘之上 程序实现逻辑： 汉诺塔的算法就3个步骤： 【1】把a上的n-1个盘通过c移动到b。 【2】把a上的最下面的盘移到c。 【3】因为n-1个盘全在b上了...
汉诺塔程序(可演示)代码
dedelili的专栏
10-16 2293
import java.applet.Applet;import java.applet.AudioClip;import java.awt.*;import java.awt.event.*;import java.util.*;public class Hnt extends Applet implements MouseListener,ActionListener,ItemListen
汉诺塔游戏动画演示 java代码
最新发布
05-02
而在实现汉诺塔游戏的过程中，Java语言被广泛应用，下面介绍一下Java实现汉诺塔游戏动画演示的代码。 在Java中实现汉诺塔游戏动画演示的关键其实就是利用递归的思想来求解游戏。具体实现步骤如下： 1. 定义汉诺塔...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值