汉诺塔 明

摘要：汉诺塔大家都知道怎么玩，就是n个圆盘从柱子A移到柱子C。在移动过程中，小盘一定要在大盘上面，所以用到起中转作用的柱子B。下面的代码中有三个解法，一个是递归的，另两个是非递归的。

稍微讲一下非递归的：

方法一、是由一位美国学者发现一种出人意料的方法，只要轮流进行两步操作就可以了。
        首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上。根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；若n为奇数，按顺时针方向依次摆放 A C B。
        （1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。
        （2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘。这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。
        （3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。

方法二、通过二叉树

        先看图，借用了凌云壮志 文章汉诺塔与二叉树 的图如下：

中序遍历这棵树就得到汉诺塔的操作过程：

1:one->three; => 2:one->two; => 1:three->two; => 3:one->three; =>1:two->one; => 2:two->three; => 1:one->three

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Hanoi
{
    struct Disk
    {
        public const int MAX = 64;

        int top; //栈顶，用来最上面的圆盘
        char name; //柱子的名字，可以是A，B，C中的一个

        int[] s; //柱子上的圆盘存储情况

        public int[] S
        {
            get
            {
                //初始化
                if (s == null)
                    s = new int[MAX];
                return s;
            }
            set
            {               
                s = value;
            }
        }

        public int Top
        {
            get { return top; }
            set { top = value; }
        }

        public char Name
        {
            get { return name; }
            set { name = value; }
        }

        public bool IsEmpty()
        {
            return top == -1;
        }
        public int Peek()//取栈顶元素
        {            
            return s[top];
        }
        public int Pop()//出栈
        {
            return s[top--];
        }
        public void Push(int x)//入栈
        {
            s[++top] = x;
        }
    }

    class Node
    {
        int number;
        char first;
        char second;
        char third;

        public int Number
        {
            get { return number; }
            set { number = value; }
        }
        internal char First
        {
            get { return first; }
            set { first = value; }
        }
        internal char Second
        {
            get { return second; }
            set { second = value; }
        }
        internal char Third
        {
            get { return third; }
            set { third = value; }
        }

        public Node GetLeft()
        {
            if (number == 1)
                return null;
            Node node = new Node();
            node.number=this.number-1;
            node.first = this.first;
            node.second = this.third;
            node.third = this.second;
            return node;
        }
        public Node GetRight()
        {
            if (number == 1)
                return null;
            Node node = new Node();
            node.number = this.number - 1;
            node.first = this.second;
            node.second = this.first;
            node.third = this.third;
            return node;
        }
    }    

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("递归实现");
            Hannoi(4, 'A', 'B', 'C');

            Console.WriteLine("非递归实现1");
            int n = 4;
            Disk[] ta = Creat(n); //给结构数组设置初值 
            long max = Pow(2, n) - 1;//移动的次数应等于2^n - 1
            Hannuota(ta, max);//移动汉诺塔的主要函数 

            Console.WriteLine("非递归实现2");
            Hanoi(4, 'A', 'B', 'C');
            Console.Read();
        }

        #region 递归实现
        static void Hannoi(int n, char a, char b, char c)
        {
            if (n == 1)
                Move(1, a, c);
            else
            {
                Hannoi(n - 1, a, c, b);
                Move(n, a, c);
                Hannoi(n - 1, b, a, c);
            }
        }
        static void Move(int n, char x, char y)
        {
            Console.WriteLine("Move disk {0} from {1} to {2}", n, x, y);
        }
        #endregion

        #region 非递归实现1
        static Disk[] Creat(int n)
        {
            Disk[] ta = new Disk[3];
            ta[0].Name = 'A';
            ta[0].Top = n - 1;
            //把所有的圆盘按从大到小的顺序放在柱子A上
            for (int i = 0; i < n; i++)
            {
                ta[0].S[i] = n - i;
            }
            //柱子B，C上开始没有没有圆盘
            ta[1].Top = ta[2].Top = -1;
            for (int i = 0; i < n; i++)
                ta[1].S[i] = ta[2].S[i] = 0;
            //若n为偶数，按顺时针方向依次摆放 A B C
            if (n % 2 == 0)
            {
                ta[1].Name = 'B';
                ta[2].Name = 'C';
            }
            else  //若n为奇数，按顺时针方向依次摆放 A C B
            {
                ta[1].Name = 'C';
                ta[2].Name = 'B';
            }
            return ta;
        }

        static long Pow(int x, int y)
        {
            long sum = 1;
            for (int i = 0; i < y; i++)
                sum *= x;

            return sum;
        }

        /// <summary>
        /// 算法介绍：首先容易证明，当盘子的个数为n时，移动的次数应等于2^n - 1。
        /// 一位美国学者发现一种出人意料的方法，只要轮流进行两步操作就可以了。
        /// 首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上。根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；若n为奇数，按顺时针方向依次摆放 A C B。
        /// （1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。
        /// （2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘。这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。
        /// （3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。
        /// </summary>
        /// <param name="ta"></param>
        /// <param name="max"></param>
        static void Hannuota(Disk[] ta, long max)
        {
            Console.WriteLine("累计移动次数：{0}", max);
            int k = 0; //累计移动的次数
            int i = 0;
            int ch;
            while (k < max)
            {
                //按顺时针方向把圆盘1从现在的柱子移动到下一根柱子
                ch = ta[i % 3].Pop();
                ta[(i + 1) % 3].Push(ch);
                ++k;
                Console.WriteLine("Move dish {0} from {1} to {2}", ch, ta[i % 3].Name, ta[(i + 1) % 3].Name);

                i++;
                //把另外两根柱子上可以移动的圆盘移动到新的柱子上
                if (k < max)
                {         //把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘
                    if (ta[(i + 1) % 3].IsEmpty() ||
                        !ta[(i - 1) % 3].IsEmpty() &&
                        ta[(i + 1) % 3].Peek() > ta[(i - 1) % 3].Peek())
                    {
                        ch = ta[(i - 1) % 3].Pop();
                        ta[(i + 1) % 3].Push(ch);
                        ++k;
                        Console.WriteLine("Move dish {0} from {1} to {2}", ch, ta[(i - 1) % 3].Name, ta[(i + 1) % 3].Name);
                    }
                    else
                    {
                        ch = ta[(i + 1) % 3].Pop();
                        ta[(i - 1) % 3].Push(ch);
                        ++k;
                        Console.WriteLine("Move dish {0} from {1} to {2}", ch, ta[(i + 1) % 3].Name, ta[(i - 1) % 3].Name);
                    }
                }
            }
        }
        #endregion

        #region 非递归实现2
        static void Hanoi(int n,char a,char b,char c)
        {
            Stack<Node> s = new Stack<Node>();
            Node p=new Node();
            p.Number = n;
            p.First = a;
            p.Second = b;
            p.Third = c;
            int i = 0;
            while (p != null || s.Count != 0)
            {
                while (p != null)
                {
                    s.Push(p);
                    p = p.GetLeft();
                }
                if (s.Count != 0)
                {
                    p = s.Pop();
                    i++;
                    Console.WriteLine("Move disk {0} from {1} to {2}", p.Number.ToString(), p.First.ToString(), p.Third.ToString());
                    p = p.GetRight();
                }
            }
            Console.WriteLine("累计移动次数：{0}", i);
        }
        #endregion
    }
}

 网上找到汉诺塔操作可视化界面 http://figue.zdbit.com/cxzp.asp 。

Java递归简单实现

//汉诺塔
public class HanoiTest {
    public static void hanoi(int n, char A,char B,char C)
    {
        //何时结束，n=1（最后一块）
        if(n==1)
        {
            move(A,C);
            return;
        }
        //把n-1个从A->B
        hanoi(n-1,A,C,B);
        //最后1个充A->C
        move(A,C);
        //把n-1个从B->C
        hanoi(n-1,B,A,C);
    }

    public static void move(char point1,char point2)
    {
        System.out.println(String.format("%c -> %c",point1,point2));
    }

    public static void main(String[] args)
    {
        hanoi(3,'A','B','C');
    }
}