Hanoi Tower

 

Hanoi tower运用递归算法。几年前没能了解其中的真正奥妙，

想通了其实很简单，呵呵

参见了《数据结构及算法分析 JAVA版》

思路：

1 设计disk和pole类，其中pole类类似于栈（先入后出）

2 利用递归算法得出移动disk的先后顺序以及移动路线，并将每一步操作信息保存至链表中

3 将链表中保存的结果打印出来

以下是汉诺塔中定义的类：

HanoiType.h

#include <stdio.h>

// disk type
class disk
{
public:
    int id;
    disk *next; // upper one
    disk *pre;  // downer one
    disk(int _id);
protected:
private:
};

disk::disk(int _id)
{
    id = _id;
    next = NULL;
    pre = NULL;
}

// pole with ordered stack data structure
class pole
{
public:
    void push(disk *_dsk);
    disk* pop();
    disk *head;    // the disk on the tower top
    pole(int _pol_id);
    ~pole();
    int pole_id;
protected:
private:
};

void pole::push(disk *_dsk)
{
    if (NULL == _dsk)
    {
        return;
    }
    if (NULL == head) // the pole is empty
    {
        head = _dsk;
    }
    else// the pole is not empty
    {
        _dsk->pre = head;
        head->next = _dsk;
        head = _dsk;
    }
}

disk* pole::pop()
{
    if (NULL == head)    // the pole is empty
    {
        return NULL;
    }
    else    // the pole is not empty
    {
        disk *tmp = head;
        head = head->pre;
        if (!head)
        {
            //head->next = NULL;
        }
        tmp->pre = NULL;
        tmp->next = NULL;
        return tmp;
    }
}

pole::~pole()
{
    disk *ptr = head;
    disk *tmp;
    while(!ptr)
    {
        tmp = ptr->pre;
        delete ptr;
        ptr = NULL;
        ptr = tmp;
    }
}

pole::pole(int _pole_id)
{
    pole_id = _pole_id;
    head = NULL;
}


class report_node
{
public:
    int disk_id;
    int src_pole_id;
    int des_pole_id;
    report_node *next;
    report_node(int _d_id, int _src_p_id, int _des_p_id);
protected:
private:
};

report_node::report_node(int _d_id, int _src_p_id, int _des_p_id)
{
    disk_id = _d_id;
    src_pole_id = _src_p_id;
    des_pole_id = _des_p_id;
    next = NULL;
}

class report
{
public:
    report_node *first, *ptr;
    void insert(report_node *node);
    report();
    ~report();
protected:
private:
};

report::report()
{
    first = NULL;
    ptr = NULL;
}

report::~report()
{
    report_node *_ptr = first;
    while(!_ptr)
    {
        delete _ptr;
        _ptr = NULL;
    }
}

void report::insert(report_node *node)
{
    if (NULL == node)
    {
        return;
    }
    else if(NULL == first)
    {
        first = node;
        ptr = node;
    }
    else
    {
        ptr->next = node;
        ptr = ptr->next;
    }
}

 

以下是源文件

Movedisks.cpp

 

#include "HanoiType.h"
#include <iostream>
using namespace std;

report *rept = new report();    // store the moving steps

/* move just one dist from src_pole to des_pol,
 * pop a disk from src and push it into 
 * des;
 */
void move_1(pole *src_pole, pole *des_pole)
{    
    if (NULL == src_pole->head)
    {
        return;
    }
    else
    {
//         cout << "move disk --" << src_pole->head->id << "-- on --"
//             << src_pole->pole_id << "-- to " << "pole " << des_pole->pole_id << endl;
        report_node *step = new report_node(src_pole->head->id, src_pole->pole_id, des_pole->pole_id);
        rept->insert(step);
        disk *src_top = src_pole->pop();
        des_pole->push(src_top);
    }
}

void move_disks(int n, pole *src_pole, pole *emp_pole, pole *des_pole)
{    
    if (0 == n)
    {
        return;
    }
    else if (1 == n)    // basic condition
    {
        move_1(src_pole, des_pole);
    }
    else
    {
        move_disks(n - 1, src_pole, des_pole, emp_pole);
        move_1(src_pole, des_pole);
        move_disks(n - 1, emp_pole, src_pole, des_pole);
    }
}


void main()
{
    int N = 3; // number of disks on src pole
    pole *src_pole = new pole(0);
    pole *emp_pole = new pole(1);
    pole *des_pole = new pole(2);
    // construct the s
    for(int i = N; i != 0; i--)
    {
        disk *d = new disk(i);
        src_pole->push(d);
    }
    // begin
    move_disks(N, src_pole, emp_pole, des_pole);
    report_node *_ptr = rept->first;
    while(_ptr)
    { 
        cout << "Move disk --" << _ptr->disk_id << " -- from pole "<<_ptr->src_pole_id << " to " << _ptr->des_pole_id << endl;
        _ptr = _ptr->next;
    }

}

 

 在report单链表中保存的移动操作步骤可以用于图形化显示（待续。。。）