汉诺塔(Tower of Hanoi)问题的求解——利用栈与递归

汉诺塔(Tower of Hanoi)问题的求解——利用栈与递归

1. 汉诺塔问题的提法

• 汉诺塔问题是使用递归解决问题的经典范例。
• 传说婆罗门庙里有一个塔台，台上有3根标号为A、B、C的用钻石做成的柱子，在A柱上放着64个金盘，每一个都比下面的略小一点。把A柱上的金盘全部移到C柱上的那一天就是世界末日。
• 移动的条件是：一次只能移动一个金盘，移动过程中大金盘不能放在小金盘上面。庙里的僧人一直在移个不停，移动的最少总次数是 264−1 次，如果每秒移动一次的话，需要500亿年。

2. 求解汉诺塔问题的算法原理

• 注：最少的移动总次数 = 2n−1 (n为盘子的个数)
• 如果n=1，则将这一个盘子直接从A柱移到C柱上，最少移动 21−1 = 1次。
• 如果n>1，则执行以下3步，最少移动 2n−1 次：
  (1)用C柱做过滤，将A柱上的(n-1)个盘子移到B柱上。
  (2)将A柱上最后一个盘子直接移到C柱上。
  (3)用A柱做过滤，将B柱上的(n-1)个盘子移到C柱上。
• 汉诺塔问题(n=3)的求解过程示例图：
  

3. 利用递归求解汉诺塔问题

3.1 汉诺塔问题的递归求解算法实现

• 文件：Hanoi.h

  
  #pragma once
  
  
  
  #include 
  
  
  #include 
  
  
  using namespace std;
  
  static int total_count = 0;
  void Hanoi(int n, string A, string B, string C)
  {
      if (n == 1)
      {
          total_count++;
          cout << total_count<< ": Move top disk from peg" << A << " to peg" << C << endl;
      }
      else
      {
          Hanoi(n - 1, A, C, B);
          total_count++;
          cout << total_count<< ": Move top disk from peg" << A << " to peg" << C << endl;
          Hanoi(n - 1, B, A, C);
      }
  }

3.2 主函数(main函数)的实现

• 文件：main.cpp

  
  #include "Hanoi.h"
  
  
  int main()
  {
      Hanoi(3, "A", "B", "C");
      system("pause");
      return 0;
  }

4. 利用栈与递归求解汉诺塔问题

4.1 链表结点结构的定义

• 文件：LinkNode.h

  
  #ifndef LINK_NODE_H_
  
  
  #define LINK_NODE_H_
  
  
  
  #include 
  
  
  #include 
  
  
  #include 
  
  
  using namespace std;
  
  template <class T>
  struct LinkNode         //链表结点类的定义
  {
      T data;             //数据域
      LinkNode *link;  //指针域——后继指针
      //仅初始化指针成员的构造函数
      LinkNode(LinkNode* ptr = NULL){ link = ptr; }
      //初始化数据与指针成员的构造函数
      LinkNode(const T& value, LinkNode* ptr = NULL){ data = value; link = ptr; }
  };
  
  
  #endif /* LINK_NODE_H_ */
  

4.2 栈的的抽象类定义

• 文件：Stack.h

  
  #ifndef STACK_H_
  
  
  #define STACK_H_
  
  
  template 
  class Stack
  {
  public:
      Stack(string name) : m_sName(name){}    //构造函数
      virtual ~Stack(){}                      //析构函数
  public:
      virtual void Push(const T& x) = 0;      //新元素x进栈
      virtual bool Pop(T& x) = 0;             //栈顶元素出栈，并将该元素的值保存至x
      virtual bool getTop(T& x) const = 0;    //读取栈顶元素，并将该元素的值保存至x
      virtual bool IsEmpty() const = 0;       //判断栈是否为空
      virtual bool IsFull() const = 0;        //判断栈是否为满
      virtual int getSize() const = 0;        //计算栈中元素个数
      virtual void MakeEmpty() = 0;           //清空栈的内容
  private:
      string m_sName;     //栈名
  };
  
  
  #endif /* STACK_H_ */
  

4.3 链式栈的类定义及其操作的实现

• 文件：LinkedStack.h

  
  #ifndef LINKED_STACK_H_
  
  
  #define LINKED_STACK_H_
  
  
  
  #include "LinkNode.h"
  
  
  #include "Stack.h"
  
  
  template <class T>
  class LinkedStack : public Stack
  {
  public:
      LinkedStack(string name);           //构造函数
      virtual ~LinkedStack();             //析构函数
  public:
      virtual void Push(const T& x) ;     //新元素x进栈
      virtual bool Pop(T& x);             //栈顶元素出栈，并将该元素的值保存至x
      virtual bool getTop(T& x) const;    //读取栈顶元素，并将该元素的值保存至x
      virtual bool IsEmpty() const;       //判断栈是否为空
      virtual bool IsFull() const;        //判断栈是否为满
      virtual int getSize() const;        //计算栈中元素个数
      virtual void MakeEmpty();           //清空栈的内容
  public:
      string get_name();                  //获取栈名
  public:
      template <class T>
      friend ostream& operator<<(ostream& os, const LinkedStack& s);   //输出栈中元素的重载操作<<
  private:
      LinkNode *top;   //栈顶指针，即链头指针
      string m_sName;     //栈名
  };
  
  //构造函数
  template <class T>
  LinkedStack::LinkedStack(string name)
  : Stack(name), top(NULL), m_sName(name)
  {
      cout << "$ 执行构造函数" << endl;
  }                       
  
  //析构函数
  template <class T>
  LinkedStack::~LinkedStack()
  {
      cout << "$ 执行析构函数" << endl;
      MakeEmpty();
  }   
  
  //新元素x进栈
  template <class T>
  void LinkedStack::Push(const T& x)
  {
      LinkNode *newNode = new LinkNode(x);
      newNode->link = top;
      top = newNode;
  }
  
  //栈顶元素出栈，并将该元素的值保存至x
  template <class T>
  bool LinkedStack::Pop(T& x)
  {
      if (true == IsEmpty())
      {
          return false;
      }
      LinkNode *curNode = top;
      top = top->link;
      x = curNode->data;
      delete curNode;
      return true;
  }
  
  //读取栈顶元素，并将该元素的值保存至x
  template <class T>
  bool LinkedStack::getTop(T& x) const
  {
      if (true == IsEmpty())
      {
          return false;
      }
      x = top->data;
      return true;
  }
  
  //判断栈是否为空
  template <class T>
  bool LinkedStack::IsEmpty() const
  {
      return (NULL == top) ? true : false;
  }
  
  //判断栈是否为满
  template <class T>
  bool LinkedStack::IsFull() const
  {
      return false;
  }
  
  //计算栈中元素个数
  template <class T>
  int LinkedStack::getSize() const
  {
      int count = 0;
      LinkNode *curNode = top;
      while (NULL != curNode)
      {
          curNode = curNode->link;
          count++;
      }
      return count;
  }
  
  //清空栈的内容
  template <class T>
  void LinkedStack::MakeEmpty()
  {
      LinkNode *curNode = NULL;
      while (NULL != top)             //当链表不为空时，删去链表中所有结点
      {
          curNode = top;              //保存被删结点
          top = curNode->link;            //被删结点的下一个结点成为头结点
          delete curNode;                 //从链表上摘下被删结点
      }
  }
  
  //获取栈名
  template <class T>
  string LinkedStack::get_name()
  {
      return m_sName;
  }
  
  //输出栈中元素的重载操作<<
  template <class T>
  ostream& operator<<(ostream& os, const LinkedStack& s)
  {
      os << "栈中元素个数 = " << s.getSize() << endl;   //输出栈中元素个数
      int i = 0;
      LinkNode *curNode = s.top;
      while (NULL != curNode)
      {
          os << "[" << i++ << "]" << " : " << curNode->data << endl;
          curNode = curNode->link;
      }
      return os;
  }
  
  
  #endif /* LINKED_STACK_H_ */
  

4.4 主函数(main函数)的实现

• 文件：main.cpp

  
  #include "LinkedStack.h"
  
  
  static int total_count = 0;
  
  //判断输入的字符串每个字符是否都是数值0~9
  bool IsNumber(const string& s_num)
  {
      for (size_t i = 0; i < s_num.size(); i++)
      {
          if ((s_num[i] < '0') || (s_num[i] > '9'))
          {
              return false;
          }
      }
      return true;
  }
  
  //输入金盘子个数n
  int get_n()
  {
      cout << "> 输入金盘子个数，n = ";
      string s_n;
      cin >> s_n;
      while (false == IsNumber(s_n))
      {
          cout << "* 输入有误，请重新输入：";
          cin >> s_n;
      }
      return atoi(s_n.c_str());
  }
  
  //构造链式栈
  template <class T>
  LinkedStack* construct_linkedstack(string name)
  {
      cout << "\n==> 创建链式栈" << endl;
      LinkedStack *linkedStack = new LinkedStack(name);
      return linkedStack;
  }
  
  //析构链式栈
  template <class T>
  void destory_linkedstack(LinkedStack* linkedStack)
  {
      cout << "\n==> 释放链式栈在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
      delete linkedStack;
      linkedStack = NULL;
  }
  
  //初始化汉诺塔的金盘子数
  template <class T>
  int initialize_Hanoi(LinkedStack* linkedStack_a)
  {
      cout << "\n==> 初始化汉诺塔的金盘子数函数" << endl;
      int n = get_n();
      for (int i = n; i > 0; i--)
      {
          linkedStack_a->Push(i);
      }
      return n;
  }
  
  //移动汉诺塔上的金盘子
  template <class T>
  void Move(LinkedStack* linkedStack_a, LinkedStack* linkedStack_b)
  {
      T data;
      linkedStack_a->Pop(data);
      linkedStack_b->Push(data);
      cout << total_count << ": Move top disk from peg" << linkedStack_a->get_name() << " to peg" << linkedStack_b->get_name() << endl;
  }
  
  //求解汉诺塔问题
  template <class T>
  void Hanoi(int n, LinkedStack* linkedStack_a, LinkedStack* linkedStack_b, LinkedStack* linkedStack_c)
  {
      if (n == 1)
      {
          total_count++;
          Move(linkedStack_a, linkedStack_c);
      }
      else
      {
          Hanoi(n - 1, linkedStack_a, linkedStack_c, linkedStack_b);
          total_count++;
          Move(linkedStack_a, linkedStack_c);
          Hanoi(n - 1, linkedStack_b, linkedStack_a, linkedStack_c);
      }
  }
  
  //输出移动后的汉诺塔的金盘子序号
  template <class T>
  void putout_Hanoi(LinkedStack* linkedStack_c)
  {
      cout << "$ 执行输出移动后的汉诺塔的金盘子序号函数" << endl;
      cout << *linkedStack_c;//或operator<<(cout, *linkedStack_c);
  }
  
  int main(int argc, char* argv[])
  {
      LinkedStack<int> *Stack_a = construct_linkedstack<int>("A");
      LinkedStack<int> *Stack_b = construct_linkedstack<int>("B");
      LinkedStack<int> *Stack_c = construct_linkedstack<int>("C");
      int n = initialize_Hanoi(Stack_a);
      Hanoi(n, Stack_a, Stack_b, Stack_c);
      putout_Hanoi(Stack_c);
      destory_linkedstack(Stack_a);
      destory_linkedstack(Stack_b);
      destory_linkedstack(Stack_c);
      system("pause");
      return 0;
  }

---

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第十章
[3] 百度搜索关键字：汉诺塔、栈与递归
[4] 汉诺塔小游戏：http://www.4399.com/flash/109504.htm