汉诺塔问题的栈实现方法

汉诺塔问题的栈实现方法

汉诺塔问题，通过递归方法实现，逻辑非常清晰，但因递归的效率问题，对于盘子数量过大的情形，会递归报错，使用栈实现汉诺塔问题，会有所改进，实现的思路，有助于理解和使用栈来解决类似的递归问题。

使用栈实现步骤的模板：

​ 1、建立任务栈和输出栈，

​ 2、建立初始任务记录，将任务记录压入任务栈，

​ 3、对任务栈进行出栈操作来完成任务，完成任务的动作压入输出栈

对不同的问题，在出栈操作时进行处理，要根据问题要求和出栈的数据，直接处理或分解后继续压入栈，直至任务栈清空。

python 实现代码如下：

class my_stack:

    def __init__(self,number):
        self.__stack = []
        i = 0
        while i < number:
            self.__stack.append(number - i)
            i = i+1

    def pop(self):
        if len(self.__stack) > 0:
            return self.__stack.pop()
        else:
            return None

    def push(self,tmp):
        self.__stack.append(tmp)

    def get_first(self):

        if len(self.__stack) > 0:
            return self.__stack[0]
        else:
            return None

    def get_last(self):

        if len(self.__stack) > 0:
            return self.__stack[len(self.__stack)-1]
        else:
            return None

    def print(self):
        i = 0
        while i < len(self.__stack):
            print('第'+str(i+1)+'条记录： ',self.__stack[i])
            i = i + 1

    def print_number(self):
        print(len(self.__stack))

    def get_number(self):
        return len(self.__stack)


def hanoi_stack_e(n):
    
    task_stack = my_stack(0)
    out_stack = my_stack(0)
    
    task_stack.push((n, 'smd'))

    while task_stack.get_last() != None:
        a_tmp = task_stack.pop()
        if a_tmp[0] > 1:
            b_tmp_l = (a_tmp[0]-1,a_tmp[1][1]+a_tmp[1][0]+a_tmp[1][2])
            b_tmp_m = (1,a_tmp[1])
            b_tmp_f =(a_tmp[0]-1,a_tmp[1][0]+a_tmp[1][2]+a_tmp[1][1])
            task_stack.push(b_tmp_l)
            task_stack.push(b_tmp_m)
            task_stack.push(b_tmp_f)
        else:
            out_stack.push(a_tmp)
            
return out_stack



#测试
n = 3
out_e = hanoi_stack_e(n)
out_e.print()

其中：

1、压入任务栈中的任务记录为一元组数据，n为盘子的数量，字符串’smd’表示从起始柱（s）通过中间柱（m）移至目标柱（d）,

2、输出栈中的记录为一元组数据，为完成任务的操作记录，1，表示移动一个盘子，‘smd’表示从将1个盘子从起始柱（s）通过中间柱（m）移至目标柱（d）,

3、其它递归问题，也可以据此思路通过栈来实现。