虽然里面是用c＋＋作为例子的，但是编程的思想：算法是通用的。就像这位老兄说的一样，俗话说：黑猫白猫，能抓到老鼠的猫最好。我们计算机编程算法设计虽然不能仅仅要求解决问题，还涉及到起码要有一个就算不能是最优也要比较优化的算法。而有时候人的思维是有局限的，我认为，所谓的算法类型也只不过是人们在编程后总结出来大量算法的共性，形成的不同类型的算法，我们大可不必为了算法而运用算法，反而使我们被人为总结的算法而局限了我们的思考。所以我决定，暂时放下所有的算法，专心的做其他事。。。
看过这样一道题，问，“程序结构化设计的三种基础结构，顺序、选择、循环是不是必须的？”当然，你知道这样一个论断，只要有这三种就足够了；但是能不能更少呢？答案是“可以”，原因就是递归能取代循环的作用，例如下面的对一个数组里面元素求和的函数：

float rsum (float a, const int n)
{
if (n <= 0) return 0;
else return rsum(a, n – 1) + a;
}

　　实际上就是：

sum = 0;
for (int i = 0; i < n; i++) sum += a;

　　但实际的情况是，任何的一种语言里面都有循环结构，但不是任何的语言都支持递归；套用一句话，递归是万能的，但没有递归不是万万不能的。然而，我看到现在的某些人，不管什么问题都要递归，明明循环是第一个想到的方法，偏偏费尽脑筋去寻找递归算法。对此，我真的不知道该说什么。

　　递归是算法吗

　　经常的看到“递归算法”、“非递归算法”，这种提法没有语义上的问题，并且我自己也这样用——递归的算法。但这也正说明了，递归不是算法，他是一种思想，正是因为某个算法的指导思想是递归的，所以才被称为递归算法；而一个有递归算法的问题，当你不使用递归作为指导思想，这样得到的算法就是非递归算法。——而对于循环能处理的问题，都有递归解法，在这个意义上说，循环算法都可以称为非递归算法。

　　我在这咬文嚼字没什么别的意思，只是想让大家知道，能写出什么样的算法，关键是看你编写算法时的指导思想。如果一开始就想到了循环、迭代的方法，你再费心耗神去找什么递归算法——即使找到了一种看似“简洁”的算法，由于他的低效实际上还是废物——你还在做这种无用功干什么？典型的学究陋习。如果你仅仅想到了递归的方法，现在你想用栈来消解掉递归，你做的工作仅仅是把系统做的事自己做了，你又能把效率提高多少？盲目的迷信消解递归就一定能提高效率是无根据的——你做的工作的方法如果不得当的话，甚至还不如系统原来的做法。

　　从学排列组合那天开始，我所知道的阶乘就是这个样子n! = 1×2×……n。如果让我来写阶乘的算法，我也只会想到从1乘到n。再如，斐波那契数列，如果有人用自然语言描述的话，一定是这样的，开始两项是0、1，以后的每项都是前面两项的和。所以让我写也只会得到“保存前两项，然后相加得到结果”的迭代解法。——现在只要是讲到递归几乎就有他们的登场，美其名曰：“定义是递归的，所以我们写递归算法”。我想问的是，定义的递归抽象是从哪里来的？显然阶乘的定义是从一个循环过程抽象来的，斐波那契数列的定义是个迭代的抽象。于是，我们先从一个本不是递归的事实抽象出一个递归的定义，然后我们说，“因为问题的定义是递归的，因此我们很容易写出递归算法”，接着说，“我们也能将这个递归算法转化为循环、迭代算法”，给人的感觉就像是1÷3＝0.33……，0.33……×3＝0.99……，然后我们花了好大的心智才明白1＝0.99……。

　　还是有那么些人乐此不疲，是凡讲到递归就要提到这两个，结果，没有一个学生看到阶乘那样定义没有疑问的，没有一个对于那个递归的阶乘函数抱有钦佩之情的——瞎折腾什么呢？所以，如果要讲递归，就要一个令人信服的例子，而这个例子非汉诺塔莫属。
汉诺塔的非递归解法

　　似乎这个问题的最佳解法就是递归，如果你想用栈来消解掉递归达到形式上的消除递归，你还是在使用递归的思想，因此，他本质上还是一个递归的算法。我们这本黄皮书在谈论到“什么情况使用递归”的时候，在“3.问题的解法是递归的”这里面，就这样说了“有些问题只能用递归的方法来解决，一个典型的例子就是汉诺塔”。

　　但我坚信，如果一个问题能用分析的办法解决——递归实际上就是一个分析解法，能将问题分解成－1规模的同等问题和移动一个盘子，如果这样分解下去一定会有解，最后分解到移动1号盘子，问题就解决了——那么我也应该能用综合的办法解决，就是从当前的状态来确定怎样移动，而不是逆推得到决定。这是对实际工作过程的一个模拟，试想如果让我们去搬盘子，我们肯定不会用递归来思考现在应该怎么搬——只要8个盘子，我们脑子里的“工作栈”恐怕就要溢出了——我们要立即决定怎么搬，而不是从多少步之后的情景来知道怎么搬。下面我们通过模拟人的正向思维来寻找这个解法。

　　假设如下搬7个盘子的初始状态（选用7个是因为我曾经写出了一个1～6结果正确的算法，而在7个的时候才发现一个条件的选择错误，具体大家自己尝试吧），我们唯一的选择就是搬动1号盘子，但是我们的问题是向B搬还是向C搬？

　　显然，我们必须将7号盘子搬到C，在这之前要把6号搬到B，5号就要搬到C，……以此类推，就会得出结论（规律1）：当前柱最上面的盘子的目标柱应该是，从当前柱上“需要搬动的盘子”最下面一个的目标柱，向上交替交换目标柱到它时的目标柱。就是说，如果当前柱是A，需要移动m个盘子，从上面向下数的第m个盘子的目标柱是C，那么最上面的盘子的目标柱就是这样：if (m % 2) 目标和第m个盘子的目标相同（C）;else 目标和第m个盘子的目标不同（B）。接下来，我们需要考虑如果发生了阻塞，该怎么办，如下所示：

　　3号盘子的目标柱是C，但是已经有了1号盘子，我们最直觉的反映就是——将碍事的盘子搬到另一根柱子上面去。于是，我们要做的是（规律2）：保存当前柱的信息（柱子号、应该搬动的最下面一块盘子的号，和它的目标柱），以备当障碍清除后回到现在的柱子继续搬，将当前柱转换为碍事的盘子所在的柱子。假设这样若干步后，我们将7号盘子从A搬到了C，此时，保存当前柱号的栈一定是空了，我们该怎么办呢？

　　显而易见的，转换当前柱为B，把6号盘子搬到C。由此可得出（规律3）：假设当前的问题规模为n，搬动第n个盘子到C后，问题规模减1，当前柱转换到另一个柱子，最下面的盘子的目标柱为C。

　　综上，我们已经把这个问题解决了，可以看出，关键是如何确定当前柱需要移动多少盘子，这个问题请大家自己考虑，给出如下例程，因为没有经过任何优化，本人的编码水平又比较低，所以这个函数很慢——比递归的还慢10倍。

#include
#include

using namespace std;
class Needle
{
public:
Needle() { a.push_back(100); }//每一个柱子都有一个底座
void push(int n) { a.push_back(n); }
int top() { return a.back(); }
int pop() { int n = a.back(); a.pop_back(); return n; }
int movenum(int n) { int i = 1;while (a > n) i++; return a.size() - i; }
int size() { return a.size(); }
int operator (int n) { return a; }
private:
vector a;
};

void Hanoi(int n)
{
Needle needle, ns;//3个柱子，ns是转换柱子时的保存栈，借用了Needle的栈结构
int source = 0, target, target_m = 2, disk, m = n;
for (int i = n; i > 0; i--) needle.push(i);//在A柱上放n个盘子
while (n)//问题规模为n，开始搬动
{
if (!m) { source = ns.pop(); target_m = ns.pop();
m = needle.movenum(ns.pop()); }//障碍盘子搬走后，回到原来的当前柱
if (m % 2) target = target_m; else target = 3 - source - target_m;//规律1的实现
if (needle.top() < needle.top())//当前柱顶端盘子可以搬动时，移动盘子
{
disk = needle.top();m--;
cout << disk << " move " << (char)(source + 0x41) << " to "<< (char)(target + 0x41) << endl;//显示搬动过程

needle.push(needle.pop());//在目标柱上面放盘子
if (disk == n) { source = 1 - source; target_m = 2; m = --n; }规律3的实现
}

else//规律2的实现
{
ns.push(needle.size() - m]);
ns.push(target_m); ns.push(source);
m = needle.movenum(needle.top());
target_m = 3 - source - target; source = target;
}
}
}

　　这个算法实现比递归算法复杂了很多（递归算法在网上、书上随便都可以找到），而且还慢很多，似乎是多余的，然而，这是有现实意义的。我不知道现在还在搬64个盘子的僧人是怎么搬的，不过我猜想一定不是先递归到1个盘子，然后再搬——等递归出来，估计胡子一打把了（能不能在人世还两说）。我们一定是马上决定下一步怎么搬，就如我上面写的那样，这才是人的正常思维，而用递归来思考，想出来怎么搬的时候，黄瓜菜都凉了。正像我们做事的方法，虽然我今生今世完不成这项事业，但我一定要为后人完成我能完成的，而不是在那空想后人应该怎么完成——如果达不到最终的结果，那也一定保证向正确的方向前进，而不是呆在原地空想。

　　由此看出，计算机编程实际上和正常的做事步骤的差距还是很大的——我们的做事步骤如果直接用计算机来实现的话，其实并不能最优，原因就是，实际中的相关性在计算机中可能并不存在——比如人脑的逆推深度是有限的，而计算机要比人脑深很多，论记忆的准确性，计算机要比人脑强很多。这也导致了一个普通的程序员和一个资深的程序员写的算法的速度常常有天壤之别。因为，后者知道计算机喜欢怎么思考。
迷宫

　　关于迷宫，有一个引人入胜的希腊神话，这也是为什么现今每当人们提到这个问题，总是兴致勃勃（对于年青人，估计是RPG玩多了），正如虽然九宫图连小学生都能做出来，我们总是自豪的说那叫“洛书”。这个神话我不复述了，有兴趣的可以在搜索引擎上输入“希腊神话 迷宫”，就能找到很多的介绍。

　　迷宫的神话讲述了一位英雄如何靠着“线团”杀死了牛头怪（玩过《英雄无敌》的朋友一定知道要想造牛头怪，就必须建迷宫，也是从这里来的），我看到的一本编程书上援引这段神话讲述迷宫算法的时候，不知是有意杜撰，还是考证不严，把这个过程叙述成：英雄靠着线团的帮助——在走过的路上铺线，每到分岔口向没铺线的方向前进，如果遇到死胡同，沿铺的线返回，并铺第二条线——走进了迷宫深处，杀死了牛头怪。然而，神话传说讲的是，英雄被当成贡品和其他的孩子送到了迷宫的深处，英雄杀死了牛头怪，靠着线团标识的路线退出了迷宫。实际上，这个线团只是个“栈”，远没有现代人赋予给它的“神奇作用”。我想作者也是RPG玩多了，总想着怎样“勇者斗恶龙”，然而，实际上却是“胜利大逃亡”。

　　迷宫问题实际上是一个心理测试，它反映了测试者控制心理稳定的能力——在一次次失败后，是否失去冷静最终陷在迷宫之中，也正体现了一句诗，“不识庐山真面目，只缘身在此山中”。换而言之，我们研究迷宫的计算机解法，并没有什么意义，迷宫就是为人设计的，而不是为机器设计的，它之所以称为“迷”宫，前提是人的记忆准确性不够高；假设人有机器那样的准确的记忆，只要他不傻，都能走出迷宫。现在可能有人用智能机器人的研究来反驳我，实际上，智能机器人是在更高的层面上模拟人的思考过程，只要它完全再现了人的寻路过程，它就能走出迷宫。但是，研究迷宫生成的计算机方法，却是有意义的，因为人们总是有虐待自己的倾向（不少人在RPG里的迷宫转了三天三夜也不知道疲倦）。

　　不管怎么说，还是亲自研究一下计算机怎么走迷宫吧。

　　迷宫的存储

　　按照惯例，用一个二维数组来表示迷宫，0表示墙，1表示通路，以后我们的程序都走下面这个迷宫。

递归法和回溯法

　　有人说，回溯实际上是递归的展开，但实际上。两者的指导思想并不一致。

　　打个比方吧，递归法好比是一个军队要通过一个迷宫，到了第一个分岔口，有3条路，将军命令3个小队分别去探哪条路能到出口，3个小队沿着3条路分别前进，各自到达了路上的下一个分岔口，于是小队长再分派人手各自去探路——只要人手足够（对照而言，就是计算机的堆栈足够），最后必将有人找到出口，从这人开始只要层层上报直属领导，最后，将军将得到一条通路。所不同的是，计算机的递归法是把这个并行过程串行化了。

　　而回溯法则是一个人走迷宫的思维模拟——他只能寄希望于自己的记忆力，如果他没有办法在分岔口留下标记（电视里一演到什么迷宫寻宝，总有恶人去改好人的标记）。

　　想到这里突然有点明白为什么都喜欢递归了，他能够满足人心最底层的虚荣——难道你不觉得使用递归就象那个分派士兵的将军吗？想想汉诺塔的解法，也有这个倾向，“你们把上面的N－1个拿走，我就能把下面的挪过去，然后你们在把那N－1个搬过来”。笑谈，切勿当真。

　　这两种方法的例程，我不给出了，网上很多。我只想对书上的递归解法发表点看法，因为书上的解法有偷梁换柱的嫌疑——迷宫的储存不是用的二维数组，居然直接用岔路口之间的连接表示的——简直是人为的降低了问题的难度。实际上，如果把迷宫抽象成（岔路口）点的连接，迷宫就变成了一个“图”，求解入口到出口的路线，完全可以用图的遍历算法来解决，只要从入口DFS到出口就可以了；然而，从二维数组表示的迷宫转化为图是个很复杂的过程。并且这种转化，实际上就是没走迷宫之前就知道了迷宫的结构，显然是不合理的。对此，我只能说这是为了递归而递归，然后还自己给自己开绿灯。

　　但迷宫并不是只能用上面的方法来走，前提是，迷宫只要走出去就可以了，不需要找出一条可能上的最短路线——确实，迷宫只是前进中的障碍，一旦走通了，没人走第二遍。下面的方法是一位游戏玩家提出来的，既不需要递归，也不需要栈来回溯——玩游戏还是有收获的。

　　另一种解法

　　请注意我在迷宫中用粗线描出的路线，实际上，在迷宫中，只要从入口始终沿着一边的墙走，就一定能走到出口，那位玩家称之为“靠一边走”——如果你不把迷宫的通路看成一条线，而是一个有面积的图形，很快你就知道为什么。编程实现起来也很简单。

　　下面的程序在TC2中编译，不能在VC6中编译——为了动态的表现人的移动情况，使用了gotoxy()，VC6是没有这个函数的，而且堆砌迷宫的219号字符是不能在使用中文页码的操作系统的32位的console程序显示出来的。如果要在VC6中实现gotoxy()的功能还得用API，为了一个简单的程序没有必要，所以，就用TC2写了，突然换到C语言还有点不适应。

#include

typedef struct hero {int x,y,face;} HERO;

void set_hero(HERO* h,int x,int y,int face){h->x=x;h->y=y;h->face=face;}
void go(HERO* h){if(h->face%2) h->x+=2-h->face;else h->y+=h->face-1;}
void goleft(HERO* h){if(h->face%2) h->y+=h->face-2;else h->x+=h->face-1;}
void turnleft(HERO* h){h->face=(h->face+3)%4;}
void turnright(HERO* h){h->face=(h->face+1)%4;}
void print_hero(HERO* h, int b)
{

gotoxy(h->x + 1, h->y + 1);

if (b)
{
switch (h->face)
{
case 0: printf("%c", 24); break;
case 1: printf("%c", 16); break;
case 2: printf("%c", 25); break;
case 3: printf("%c", 27); break;
default: break;
}
}
else printf(" ");
}

int maze =
{
0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
1, 0, 1, 1, 0, 1, 1, 1, 1, 0,
1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 1, 1, 0, 1, 1, 1,
0, 0, 1, 0, 1, 1, 0, 0, 0, 1,
1, 0, 1, 0, 1, 1, 0, 1, 0, 1,
0, 0, 1, 0, 1, 1, 0, 1, 0, 1,
0, 1, 1, 0, 0, 0, 0, 1, 0, 1,
0, 0, 0, 0, 1, 0, 1, 1, 0, 1,
0, 1, 1, 1, 1, 0, 0, 0, 0, 0

};

void print_maze()
{
int i, j;
for (i = 0; i < 10; i++)
{
for (j = 0; j < 10; j++)
{

if (maze) printf("%c", 219);

else printf(" ");

}

printf("\n");

}

}

int gomaze(HERO* h)

{

HERO t = *h; int i;

for (i = 0; i < 2; t = *h)

{

print_hero(h, 1); sleep(1); go(%26amp;t);

if (t.x >= 0 %26amp;%26amp; t.x < 10 %26amp;%26amp; t.y >= 0 %26amp;%26amp; t.y < 10 %26amp;%26amp; !maze)

{

print_hero(h, 0); go(h);/*前方可走则向前走*/

if (h->x == 9 %26amp;%26amp; h->y == 9) return 1; goleft(%26amp;t);

if (h->x == 0 %26amp;%26amp; h->y == 0) i++;

if (t.x >= 0 %26amp;%26amp; t.x < 10 %26amp;%26amp; t.y >= 0 %26amp;%26amp; t.y < 10 %26amp;%26amp; !maze) turnleft(h);/*左方无墙向左转*/

}

else turnright(h);/*前方不可走向右转*/

}

return 0;

}

main()
{
HERO Tom;/*有个英雄叫Tom*/
set_hero(%26amp;Tom, 0, 0, 0);/*放在(0,0)面朝北*/
clrscr();
print_maze();
gomaze(%26amp;Tom);/*Tom走迷宫*/
}

　　总结

　　书上讲的基本上就这些了，要是细说起来，几天几夜也说不完。前面我并没有讲如何写递归算法，实际上给出的都是非递归的方法，我也觉得有点文不对题。我的目的是使大家明白，能写出什么算法，主要看你解决问题的指导思想，换而言之，就是对问题的认识程度。所以初学者现在就去追求“漂亮”的递归算法，是不现实的，结果往往就是削足适履，搞的一团糟——有位仁兄写了个骑马游世界的“递归”程序，在我机器上10分钟没反映。其实优秀的递归算法是在对问题有了清楚的认识后才会得出的。

新人 要叫发贴