CCI_Q3.4

本文参考该作者文章当作编程笔记：

作者：Hawstein
出处：http://hawstein.com/posts/ctci-solutions-contents.html

Q:

编程解决汉诺塔问题，使用数据结构栈.

思路：

1.递归：分成3个状态：

1. 将src上的1~n-1个盘子借助dst移到bri上。
2. 将src上的剩下的第n个盘子移动到dst上。
3. 将bri上的1~n-1个盘子借助src移动到dst上。

参考：http://hawstein.com/posts/3.4.html

2.使用栈的非递归：

另一种汉诺塔移动方式：

1. 3个柱子呈品字型放置，形成循环。如果盘子数目n是奇数，那么排放方式：A-》C-》B；如果是偶数，那么排列方式：A-》B-》C。
2. 汉诺塔总共移动的步数是2ⁿ-1步。
3. 将1号盘子由当前柱子（1号）移动到下一个柱子（2号）。
4. 在1号柱子和3号柱子中选择一个非空的或者盘子比较小的柱子，将其上面的盘子移动到另外一个。
5. 重复3和4，直到到达总步数。
6. 成功。

参考：http://blog.minidx.com/2008/01/30/457.html

3.非递归

参考：http://www.zdyi.com/blog/hanoi/817

CODE：

1和2：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define less(A,B)(A<B)
#define N 5
#define Null 0
void hanoi(int n,char src,char bri,char dst)
{
    if(n==0)
        return;
    hanoi(n-1,src,dst,bri);
    printf("move %d from %c to %c
",n,src,dst);
    hanoi(n-1,bri,src,dst);
}
typedef struct stack_h
{
    int s[N];
    int cur;
    char name;
    //void (*stack_hPush)(int,struct stack_h*);
    //int (*stack_hPop)(int);
    //int (*stack_hTop)(int);
}Stack_h;
void stack_hPush(int item,Stack_h *h)
{
    if(h->cur == (N-1))
        return;
    h->s[++h->cur]=item;
}
int stack_hPop(Stack_h *h)
{
    if(h->cur==Null)
        return Null;
    return h->s[h->cur--];
}
int stack_hTop(Stack_h *h)
{
    if(h->cur!=Null)
        return h->s[h->cur];
    return Null;
}
int main()
{
    hanoi(4,'A','B','C');
    printf("*****************************
");
    Stack_h h1={{Null,4,3,2,1},N-1,'A'},
            h2={{Null},Null,'B'},
            h3={{Null},Null,'C'};
    if((N-1)%2!=0)
    {
        h2.name='C';
        h3.name='B';
    }
    int step_num=pow(2,N-1)-1 , step_cout=0;
    while(step_cout<=step_num)
    {
        if(stack_hTop(&h1)==1)
        {
            stack_hPush(stack_hPop(&h1),&h2); 
            printf("move 1 from %c to %c
",h1.name,h2.name);
            ++step_cout;
            if(step_cout==step_num)
                break;
            if(stack_hTop(&h1)==Null)
            {
                stack_hPush(stack_hPop(&h3),&h1); 
                printf("move %d from %c to %c
",
                        stack_hTop(&h1),h3.name,h1.name);
            }
            else if(stack_hTop(&h3)==Null)
            {
                stack_hPush(stack_hPop(&h1),&h3);
                printf("move %d from %c to %c
",
                        stack_hTop(&h3),h1.name,h3.name);
            }
            else
            {
                if(less(stack_hTop(&h1) , stack_hTop(&h3)))
                {
                    stack_hPush(stack_hPop(&h1),&h3); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h3),h1.name,h3.name);
                }
                else
                {
                    stack_hPush(stack_hPop(&h3),&h1); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h1),h3.name,h1.name);
                }
            }
        }
        else if(stack_hTop(&h2)==1)
        {
            stack_hPush(stack_hPop(&h2),&h3); 
            printf("move 1 from %c to %c
",h2.name,h3.name);
            ++step_cout;
            if(step_cout==step_num)
                break;
            if(stack_hTop(&h1)==Null)
            {
                stack_hPush(stack_hPop(&h2),&h1); 
                printf("move %d from %c to %c
",
                        stack_hTop(&h1),h2.name,h1.name);
            }
            else if(stack_hTop(&h2)==Null)
            {
                stack_hPush(stack_hPop(&h1),&h2);
                printf("move %d from %c to %c
",
                        stack_hTop(&h2),h1.name,h2.name);
            }
            else
            {
                if(less(stack_hTop(&h1) , stack_hTop(&h2)))
                {
                    stack_hPush(stack_hPop(&h1),&h2); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h2),h1.name,h2.name);
                }
                else
                {
                    stack_hPush(stack_hPop(&h2),&h1); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h1),h2.name,h1.name);
                }
            }
        }
        else 
        {
            stack_hPush(stack_hPop(&h3),&h1); 
            printf("move 1 from %c to %c
",h3.name,h1.name);
            ++step_cout;
            if(step_cout==step_num)
                break;
            if(stack_hTop(&h3)==Null)
            {
                stack_hPush(stack_hPop(&h2),&h3); 
                printf("move %d from %c to %c
",
                        stack_hTop(&h3),h2.name,h3.name);
            }
            else if(stack_hTop(&h2)==Null)
            {
                stack_hPush(stack_hPop(&h3),&h2);
                printf("move %d from %c to %c
",
                        stack_hTop(&h2),h3.name,h2.name);
            }
            else
            {
                if(less(stack_hTop(&h3) , stack_hTop(&h2)))
                {
                    stack_hPush(stack_hPop(&h3),&h2); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h2),h3.name,h2.name);
                }
                else
                {
                    stack_hPush(stack_hPop(&h2),&h3); 
                    printf("move %d from %c to %c
",
                            stack_hTop(&h3),h2.name,h3.name);
                }
            }
        }
        ++step_cout;
    }

    return 0;
}

缺点：

使用栈的非递归2的程序写的很烂.有很多地方可以优化：例如可以把3个栈设为数组，通过不断加下标i，然后和3取余，确定柱子。还可以把重复的写成一个函数。等等。