汉诺塔问题的Java实现

汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。上帝创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上安大小顺序摞着64片黄金圆盘。上帝命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

//汉诺塔
public class NewHanoi {
   public static int tiers = 4; // tiers 层数
   private static List<String> pagoda1 = new ArrayList<String>(); // 静态指针
   private static List<String> pagoda2 = new ArrayList<String>();

    private static List<String> pagoda3 = new ArrayList<String>(); 

    // 映射,用来确定并打印塔的序号(使用角标),也可以使用 Map

    private static List[] mapping = {pagoda1, pagoda2, pagoda3};


   public static void main(String[] args) { 
        preparePagoda(pagoda1, tiers); 
        System.out.println("初始状态：");
       printPagodas(); 
       hanoi(tiers, pagoda1, pagoda2, pagoda3); 
        System.out.println("最后结果：");
       printPagodas();
   }
    // --准备盘子(添加-字符串) (源塔)上
    private static void preparePagoda(List<String> srcPagoda, int tiers) {

        // 用于拼装塔层的容器
        StringBuilder builder = new StringBuilder();

        // 源塔的每一层加盘子，从底层开始, i ‘代表’盘子的直径大小，等于组成盘子的"^"个数
        for(int i = tiers; i > 0; i--){            

            // 每一层由 2*tiers-1 个格子组成，代表盘子大小的"^"格子由空格隔开
            for(int k = 0; k < tiers - i; k++) builder.append(" "); // 盘子左边的空格，数量为 [2*tiers-1-(2*i-1)]/2 = tiers-i, 右边相同
            for(int j = 1; j <= 2*i-1; j++){        // 盘子所占格数
                if(j % 2 == 1) builder.append("^"); // 间隔摆放

                else builder.append(" ");
            }
            for(int k = 0; k < tiers - i; k++) builder.append(" "); // 盘子右边的空格

            srcPagoda.add(builder.toString());    // 添加到塔上
            builder.delete(0, builder.length());  // 下一循环前清空容器
        }
   }
    // --打印塔的现状

    private static void printPagodas(){

         // 打印层数为三座塔-现状的最大高度
        int len = Math.max(pagoda1.size(), Math.max(pagoda2.size(), pagoda3.size()));
        // 用于-塔的空层显示

        StringBuilder spaces = new StringBuilder(); 
        spaces.append("-");   // --添加塔的左外框
        for(int i = 0; i < 2*tiers-1; i++) spaces.append(" "); // 空层显示用空格
        spaces.append("-\t"); // --添加塔的右外框和塔间间隔       

       

        for(int i = len - 1; i >= 0; i--){ // 从顶层开始            

            // 三座塔同一水平面的塔层放在同一行显示
           // 当某个塔不存在此层时，List.get(index)会抛角标越界异常，使用try-catch处理：此层显示一层空格 
            try {  System.out.print("-" + pagoda1.get(i) + "-\t");
           } catch (Exception e1) { System.out.print(spaces);
            }
            try {  System.out.print("-" + pagoda2.get(i) + "-\t");
           } catch (Exception e) { System.out.print(spaces);
            }
            try {  System.out.print("-" + pagoda3.get(i) + "-\t");
           } catch (Exception e) { System.out.print(spaces);
            }
            System.out.print("\r\n");
        }
   }
    // 这个方法(递归的核心方法)从指定的源塔上移动-指定数量的盘子-到指定的目标塔上

    public static void hanoi(int moveNum, List<String> from, List<String> middle, List<String> to) {
        if(moveNum == 1){ // 递归到移动一个盘子时，使用 move 方法 
           moveTheTopOne(from, to);
            return;
       }

        // 将实现分为三步，一，将源塔底盘上方的所有盘子移至中间塔(递归)；二，将底盘移到目标塔；三，将中间塔上的所有盘子移到目标塔上(递归)。
        hanoi(moveNum - 1, from, to, middle);
       moveTheTopOne(from, to);
       hanoi(moveNum - 1, middle, from, to);
   }
   // 方法的名字就是他的作用
   private static void moveTheTopOne(List<String> from, List<String> to) {
       String theTopOne = from.remove(from.size() - 1);
       to.add(theTopOne);

        // 打印图形，每移动一下，打印图形显示
        System.out.println("********** print ***********\r\n");
       // 确定塔的序号
       int fromNum = 0, toNum = 0;
       for (int i = 0; i < mapping.length; i++) { // 遍历塔的数组
   
           if (mapping[i] == from) {
                fromNum = i+1;
           }
           if (mapping[i] == to) {
                toNum = i+1;
           }
       }
       System.out.println("从 " + fromNum + " 号塔往 " + toNum + " 号塔\r\n");

       printPagodas(); // 打印图形
   }
} 






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; iadisk.length; i++)
    adisk = 1;
   bdisk = new int[diskNum];
   for(int k=0; kbdisk.length; k++)
    bdisk[k] = 0;
   cdisk = new int[diskNum];
   for(int i=0; icdisk.length; i++)
    cdisk = 0;
   repaint();
   if(animate == null || !animate.isAlive())//创建一个线程
   {
    animate = new Thread(this);
    animate.start();
   }
  }
  if(command.equals("停止"))
  {
   for(int k=0; kbdisk.length; k++)
    bdisk[k] = 0;
   for(int i=0; icdisk.length; i++)
    cdisk = 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){}
}
}