河内塔与堆栈实现和递归(Java)

时间:2017-10-14 08:46:58

标签: java algorithm recursion stack towers-of-hanoi

我正在尝试通过递归来解决河内塔问题,同时使用堆栈。使用n#增加大小的磁盘,输出应如下所示。磁盘必须一次从一个Pillar1移动到Pillar3:

// assuming n = 3;

Pillar1: 3 2 1

Pillar2:

Pillar3: 

// "\n"

Pillar1: 3 2 

Pillar2:

Pillar3: 1

// "\n"

Pillar1: 3 

Pillar2: 2

Pillar3: 1


// "\n"

Pillar1: 3 

Pillar2: 2 1

Pillar3: 


// "\n"

Pillar1: 

Pillar2: 2 1

Pillar3: 3


// "\n"

Pillar1: 1

Pillar2: 2

Pillar3: 3

// "\n"

Pillar1: 1

Pillar2: 

Pillar3: 3 2


// "\n"

Pillar1: 

Pillar2: 

Pillar3: 3 2 1

我的代码如下,我在输出磁盘时遇到困难> 1:

import java.util.*;
class TowersOfHanoiThree
{
   public static Stack<Integer>[] tower = new Stack[4];
   public static int temp;

   public static void TowersOfHanoiThree(int numDisk)
   {
      //adding disk to stack
      temp = numDisk;
      tower = new Stack[4];

      for(int a = 0; a <= 3; a++)
      {
         tower[a] = new Stack<Integer>();
      }

     for (int i = numDisk; i > 0; i--)
     {
        tower[1].push(numDisk);
        show();
     }
     solver(numDisk, 1, 3, 2);
 }

public static void show()
{
   //System.out.println("Pillar1: ");
   //System.out.println("Pillar2: ");
   //System.out.println("Pillar3: ");

   String Pillar1 = "Pillar1: ";
   String Pillar2 = "Pillar2: ";
   String Pillar3 = "Pillar3: ";

   for(int x = temp -1 ; x >= 0 ; x--)
   {
      String emptStr1 = "";
      String emptStr2 = "";
      String emptStr3 = "";

     try
     {
        emptStr1 = String.valueOf(tower[1].get(x));
     }
     catch(Exception e)
     {
     }

     try
     {
        emptStr2 = String.valueOf(tower[2].get(x));
     }
     catch(Exception e)
     {
     }

     try
     {
        emptStr3 = String.valueOf(tower[3].get(x));
     }
     catch(Exception e)
     {
     }
     System.out.print(Pillar1+emptStr1+"\n");
     System.out.print(Pillar2+emptStr2+"\n");
     System.out.print(Pillar3+emptStr3+"\n");
     System.out.print("\n");
  }
}//end show

public static void solver(int numDisk, int start, int middle, int end) 
{
   if(numDisk > 0) 
   {
      try
      {
         //sorting disks
         solver(numDisk - 1, start, end, middle);
         int dis = tower[start].pop(); //move disk top-most disk of start
         tower[middle].push(dis);
         show();
         solver(numDisk - 1, middle, start, end);
      }
      catch(Exception e)
      {
      }
   }
}

public static void main(String args[])
{
    tower[1] = new Stack<Integer>();
    tower[2] = new Stack<Integer>();
    tower[3] = new Stack<Integer>();

    TowersOfHanoiThree(2);
}
}

2 个答案:

答案 0 :(得分:0)

使用以下实现应该可以提供所需的结果。我还对所做的修改提出了一些内联评论

public static void TowersOfHanoiThree(int numDisk)
{
  //adding disk to stack
  temp = numDisk;
  tower = new Stack[4];

  for(int a = 0; a <= 3; a++)
  {
     tower[a] = new Stack<Integer>();
  }

 for (int i = numDisk; i > 0; i--)
 {
    tower[1].push(i); // to show "1 2 3" i changed the value which was pushed in the stack
// from tower[1].push(numDisk) to tower[1].push(i)
 }
 show(); //In your example this method call was placed inside the for loop.
//Moving it outside will show the stacks only after the values are added
 solver(numDisk, 1, 3, 2);
}

 public static void show() {
    // System.out.println("Pillar1: ");
    // System.out.println("Pillar2: ");
    // System.out.println("Pillar3: ");

    String Pillar1 = "Pillar1: ";
    String Pillar2 = "Pillar2: ";
    String Pillar3 = "Pillar3: ";

    String emptStr1 = "";
    String emptStr2 = "";
    String emptStr3 = "";
//the empStr variable are moved outside the loop because only after the 
//loop has finished we know what values are in each pillar
    for (int x = 0; x <= temp - 1; x++) {

        try {
//here we just append the values from the pillar to string empStr1
            emptStr1 += String.valueOf(tower[1].get(x)) + " ";
        } catch (Exception e) {
        }

        try {
            emptStr2 += String.valueOf(tower[2].get(x)) + " ";
        } catch (Exception e) {
        }

        try {
            emptStr3 += String.valueOf(tower[3].get(x)) + " ";
        } catch (Exception e) {
        }
    }
//finally when the loop is done we have the results
    System.out.print(Pillar1 + emptStr1 + "\n");
    System.out.print(Pillar2 + emptStr2 + "\n");
    System.out.print(Pillar3 + emptStr3 + "\n");
    System.out.print("\n");
}// end show

答案 1 :(得分:0)

您需要解决一些问题。我会尽力解释它们并提供可能的解决方案。

首先,您始终将numDisks推送到TowersOfHanoiThree(int)方法的初始堆栈(支柱)上。 违规部分:

for (int i = numDisk; i > 0; i--) {
   tower[1].push(numDisk); // should be tower[1].push(i);
   show();
}

修正:

for (int i = numDisk; i > 0; i--) {
   tower[1].push(i); // fixed
   show();
}

其次,您的show()方法由于多种原因而无法正确显示:

  1. 您应该从索引0而不是最后一个索引(tower)开始遍历数组temp - 1中的每个堆栈,因为您要从底部到顶部显示磁盘。
  2. 您应该在emptStr1循环之前声明您的字符串emptStr2emptStr3for。目前,您每次迭代都会重置它们以清空字符串。
  3. 您需要将磁盘连接到字符串emptStr1emptStr2emptStr3,而不是通过重新分配来覆盖它们。
  4. 您应该在for循环后输出字符串emptStr1emptStr2emptStr3
  5. 我建议完全重写show(),例如:

    public static void show() {
        for (int i = 1; i < tower.length; i++) { // iterate over your array of stacks
            String pillar = "Pillar " + i + ":"; // e.g. "Pillar 1: "
            for (int disk : tower[i]) { // iterate over the stack located at index i
                pillar += " " + disk; // concatenate the current disk to the String
            }
            System.out.println(pillar); // Display this pillar
        }
        System.out.println(); // Line break to seperate the show() calls
    }
    

    最后solver(int, int, int, int)中的第二次递归调用不正确。

    违规行:

    solver(numDisk - 1, middle, start, end);
    

    这应该改为:

    solver(numDisk - 1, end, middle, start);
    

    另外,虽然不是失败的原因,但您的数组tower的容量为4,但它应为3.您当前忽略索引0.我认为你是故意这样做的,因为你想把支柱显示为1,2和3?无论如何,这可能令人困惑。相反,当您显示支柱信息时,只需在索引中添加1即可。