pascal递归算法

① PASCAL 递归算法的非递归实现问题 高分！

手写一个stack,
然后每当需要recursive
call的时候push
stack,
stack非空的时候pop并处理.
相当于模拟一个call
stack.
即:
procere
make1_non_rec(tx,ty:integer);
var
i,x,y:integer;
begin
stack.clear();
stack.push(tx,ty);
while(!stack.empty())
begin
x:=stack.top().x;
y:=stack.pop().y;
g[x,y]:=p;
for
i:=1
to
8
do
if
(g[x+u[i],y+v[i]]=0)
and
(a[x+u[i],y+v[i]]=a[x,y])
then
stack.push(x+u[i],y+v[i]);
end
end;

② Pascal算法之回溯及递推详细介绍、

递归 递归是计算机科学的一个重要概念,递归的方法是程序设计中有效的方法,采用递归编写程序能是程序变得简洁和清晰.2.1 递归的概念
1.概念一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数).如:procere a; begin . . . a; . . .end;这种方式是直接调用.又如: procere b; procere c; begin begin . . . . . . c; b; . . . . . .end; end;这种方式是间接调用.例1计算n!可用递归公式如下: 1 当 n=0 时 fac(n)={n*fac(n-1) 当n>0时可编写程序如下:program fac2;varn:integer;function fac(n:integer):real;beginif n=0 then fac:=1 else fac:=n*fac(n-1)end;beginwrite('n=');readln(n);writeln('fac(',n,')=',fac(n):6:0);end.例2 楼梯有n阶台阶,上楼可以一步上1阶,也可以一步上2阶,编一程序计算共有多少种不同的走法.设n阶台阶的走法数为f(n)显然有 1 n=1 f(n)={2 n=2 f(n-1)+f(n-2) n>2可编程序如下：program louti;var n:integer;function f(x:integer):integer;beginif x=1 then f:=1 elseif x=2 then f:=2 else f:=f(x-1)+f(x-2);end;beginwrite('n=');read(n);writeln('f(',n,')=',f(n))end.2.2 如何设计递归算法
1.确定递归公式2.确定边界(终了)条件练习:用递归的方法完成下列问题1.求数组中的最大数2.1+2+3+...+n3.求n个整数的积4.求n个整数的平均值5.求n个自然数的最大公约数与最小公倍数6.有一对雌雄兔,每两个月就繁殖雌雄各一对兔子.问n个月后共有多少对兔子?7.已知:数列1,1,2,4,7,13,24,44,...求数列的第 n项. 2.3典型例题例3 梵塔问题 如图:已知有三根针分别用1,2,3表示,在一号针中从小放n个盘子,现要求把所有的盘子 从1针全部移到3针,移动规则是:使用2针作为过度针,每次只移动一块盘子,且每根针上不能出现大盘压小盘.找出移动次数最小的方案. 程序如下:program fanta;varn:integer;procere move(n,a,b,c:integer);beginif n=1 then writeln(a,'--->',c)else beginmove(n-1,a,c,b);writeln(a,'--->',c);move(n-1,b,a,c);end;end;beginwrite('Enter n=');read(n);move(n,1,2,3);end.例4 快速排序快速排序的思想是:先从数据序列中选一个元素,并将序列中所有比该元素小的元素都放到它的右边或左边,再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1, 处理结束.程序如下:program kspv;
const n=7;
type
arr=array[1..n] of integer;
var
a:arr;
i:integer;
procere quicksort(var b:arr; s,t:integer);
var i,j,x,t1:integer;
begin
i:=s;j:=t;x:=b[i];
repeat
while (b[j]>=x) and (j>i) do j:=j-1;
if j>i then begin t1:=b[i]; b[i]:=b[j];b[j]:=t1;end;
while (b[i]<=x) and (i<j) do i:=i+1;
if i<j then begin t1:=b[j];b[j]:=b[i];b[i]:=t1; end
until i=j;
b[i]:=x;
i:=i+1;j:=j-1;
if s<j then quicksort(b,s,j);
if i<t then quicksort(b,i,t);
end;
begin
write('input data:');
for i:=1 to n do read(a[i]);
writeln;
quicksort(a,1,n);
write('output data:');
for i:=1 to n do write(a[i]:6);
writeln;
end.练习:1.计算ackerman函数值: n+1 m=0 ack(m,n)={ ack(m-1,1) m<>0 ,n=0 ack(m-1,ack(m,n-1)) m<>0,n<>0 求ack(5,4)
回溯 回溯是按照某种条件往前试探搜索,若前进中遭到失败,则回过头来另择通路继续搜索.3.1 回溯的设计 1.用栈保存好前进中的某些状态.2.制定好约束条件例1由键盘上输入任意n个符号;输出它的全排列.program hh;
const n=4;
var i,k:integer;
x:array[1..n] of integer;
st:string[n];
t:string[n];
procere input;
var i:integer;
begin
write('Enter string=');readln(st);
t:=st;
end;
function place(k:integer):boolean;
var i:integer;
begin
place:=true;
for i:=1 to k-1 do
if x[i]=x[k] then
begin place:=false; break end ;
end;
procere print;
var i:integer;
begin
for i:=1 to n do write(t[x[i]]);
writeln;
end;
begin
input;
k:=1;x[k]:=0;
while k>0 do
begin
x[k]:=x[k]+1;
while (x[k]<=n) and (not place(k)) do x[k]:=x[k]+1;
if x[k]>n then k:=k-1
else if k=n then print
else begin k:=k+1;x[k]:=0 end
end ;
end.例2.n个皇后问题:program hh;
const n=8;
var i,j,k:integer;
x:array[1..n] of integer;
function place(k:integer):boolean;
var i:integer;
begin
place:=true;
for i:=1 to k-1 do
if (x[i]=x[k]) or (abs(x[i]-x[k])=abs(i-k)) then
place:=false ;
end;
procere print;
var i:integer;
begin
for i:=1 to n do write(x[i]:4);
writeln;
end;
begin
k:=1;x[k]:=0;
while k>0 do
begin
x[k]:=x[k]+1;
while (x[k]<=n) and (not place(k)) do x[k]:=x[k]+1;
if x[k]>n then k:=k-1
else if k=n then print
else begin k:=k+1;x[k]:=0 end
end ;end.回溯算法的公式如下:3.2 回溯算法的递归实现由于回溯算法用一栈数组实现的,用到栈一般可用递归实现。上述例1的递归方法实现如下：program hh;
const n=4;
var i,k:integer;
x:array[1..n] of integer;
st:string[n];
t:string[n];
procere input;
var i:integer;
begin
write('Enter string=');readln(st);
t:=st;
end;
function place(k:integer):boolean;
var i:integer;
begin
place:=true;
for i:=1 to k-1 do
if x[i]=x[k] then
begin place:=false; break end ;
end;
procere print;
var i:integer;
begin
for i:=1 to n do write(t[x[i]]);
writeln;readln;
end;
procere try(k:integer);
var i :integer;
begin
if k=n+1 then begin print;exit end;
for i:=1 to n do
begin
x[k]:=i;
if place(k) then try(k+1)
end
end;
begin
input;
try(1);
end.例2：n皇后问题的递归算法如下：程序1：program hh;
const n=8;
var i,j,k:integer;
x:array[1..n] of integer;
function place(k:integer):boolean;
var i:integer;
begin
place:=true;
for i:=1 to k-1 do
if (x[i]=x[k]) or (abs(x[i]-x[k])=abs(i-k)) then
place:=false ;
end;
procere print;
var i:integer;
begin
for i:=1 to n do write(x[i]:4);
writeln;
end;
procere try(k:integer);
var i:integer;
begin
if k=n+1 then begin print; exit end;
for i:= 1 to n do
begin
x[k]:=i;
if place(k) then try(k+1);
end;
end ;
begin
try(1);
end.程序2：说明:当n=8 时有30条对角线分别用了l和r数组控制，用c数组控制列.当(i,j)点放好皇后后相应的对角线和列都为false.递归程序如下:program nhh;
const n=8;
var s,i:integer;
a:array[1..n] of byte;
c:array[1..n] of boolean;
l:array[1-n..n-1] of boolean;
r:array[2..2*n] of boolean;
procere output;
var i:integer;
begin
for i:=1 to n do write(a[i]:4);
inc(s);writeln(' total=',s);
end;
procere try(i:integer);
var j:integer;
begin
for j:=1 to n do
begin
if c[j] and l[i-j] and r[i+j] then
begin
a[i]:=j;c[j]:=false;l[i-j]:=false; r[i+j]:=false;
if i<n then try(i+1) else output;
c[j]:=true;l[i-j]:=true;r[i+j]:=true;
end;
end;
end;
begin
for i:=1 to n do c[i]:=true;
for i:=1-n to n-1 do l[i]:=true;
for i:=2 to 2*n do r[i]:=true;
s:=0;try(1);
writeln;
end.练习：1.找出所有从m个元素中选取n(n<=m)元素的组合。2.设有A,B,C,D,E 5人从事j1,j2,j3,j4,j5 5项工作每人只能从事一项,它们的效益表如下:求最佳安排,使效益最高.3.N个数中找出M个数(从键盘上输入正整数N,M后再输入N个正数),要求从N个数中找出若干个数,使它们的和为M,把满足条件的数组找出来,并统计组数.4.地图着色。如下图12个区域用4种颜色着色要求相邻的区域着不同的颜色5.将任意一正整数(1<n<100)分解成若干正整数的和. 如:4=1+1+1+1 =2+1+1 =2+2 =3+1.

③ pascal 递归的方法做问题

我直接写出最重要的把，只写子程序好了。
3：
procere f（x，s:longint);
begin
if x=0 then begin writeln(s);exit;end;
f(x div 10,s*10+x mod 10);
end;
主程序中： f(x,0);(x是要颠倒的数）；

6：
procere f（x，s，t:longint);
begin
if t=0 then begin writeln(s);exit;end;(我直接用颠倒数字，为了防止最后的零不输出，我就设定了位数）
f(x div 10,s*10+x mod 10,t-1);
end;
procere f1（x，s:longint);
var
t:longint;
begin
if x=0 then begin f(s,0,t);end;
t:=t+1;
f(x div m,s*10+(x mod m)）;
end;

主程序中：readln（m）；（进制）；f1（x，0）；（x是要换进制的数）；
如果用数组的话可以更好一点，我这样直接

④ 【Pascal递归函数】计算ackerman函数值；

两个问题：
1、Integer太小了，数据早就爆了；
2、栈的调用过头了，“exitcode = 201”的意思就是栈溢出。

事实上，阿克曼函数的值是极大的。
Ackermann(0,n)=n+1
Ackermann(1,n)=n+2
Ackermann(2,n)=2*n+3
Ackermann(3,n)=2^(n+3)-3
Ackermann(4,n)=2^2^2^……^2-3，乘幂中共有n+3个2。
当m≥4，Ackermann函数的增长快得惊人。Ackermann(4,0)=13，Ackermann(4,1)=65533，Ackermann(4,2)=2^65536-3有19729位，而Ackermann(4,3)则即使是位数也不易估计。Ackermann(5,0)=65533，Ackermann(5,1)=Ackermann(4,65533)……

针对于小数据，你的程序没问题。

⑤ PASCAL 递归算法的非递归实现问题 高分！

手写一个stack, 然后每当需要recursive call的时候push stack, stack非空的时候pop并处理. 相当于模拟一个call stack. 即:

procere make1_non_rec(tx,ty:integer);
var
i,x,y:integer;
begin
stack.clear();
stack.push(tx,ty);
while(!stack.empty())
begin
x:=stack.top().x;
y:=stack.pop().y;
g[x,y]:=p;
for i:=1 to 8 do
if (g[x+u[i],y+v[i]]=0) and (a[x+u[i],y+v[i]]=a[x,y]) then
stack.push(x+u[i],y+v[i]);
end
end;

⑥ 10道pascal的递归习题，简单一点啊

1. 有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第3个人，又说比第2个人大2岁。问第2个人，说比第1个人大2岁。最后问第1个人，他说是10岁。请问第5个人多大。显然，这是一个递归问题。要求第5个人的年龄，就必须先知道第4个人的年龄，而第4个人的年龄也不知道，要求第4个人的年龄必须先知道第3个人的年龄，而第3个人的年龄又取决于第2个人的年龄，第2个人的年龄取决于第1个人的年龄。而且每一个人的年龄都比其前1个人的年龄大2。
2.用递归方法求n！
3.用递归方法求斐波那契数列
4.有1*n的一个长方形，用一个1＊1、1＊2、1＊3的骨牌铺满方格。例如当n=3时为1＊3的方格。此时用1＊1，1＊2，1＊3的骨牌铺满方格，共有四种铺法。图4.4.3列出了四种铺法。
5.设s是一个具有n个元素的集合s={a1,a2,…an},现将s集合划分成k个满足下列条件的子集合s1,s2，s3。。。。；
1、si<>空；
2、si∩sj=空；
3、s1∪s2∪s3…. ∪sn=s (1<=i,j<=k,i<>j)
则称s1,s2…sn是集合s的一个划分，它相当于把集合s中的n个元素放入k个无标号的盒子中，使得没有一个盒子为空，试确定n个元素的集合放入k个无标号盒的划分数s(n,k)
6.设有一个背包，可以放入的重量为s。现有n件物品，重量分别为t1 , t2 , t3 … ti … tn ，ti (1≤ i≤n)，均为正整数。从n件物品中挑选若干件，使得放入背包的重量之和正好为s
【输入样例】 【输出样例】
the number of object:5 number:1 weight:1
total weight=10 number:3 weight: 2
1 6 2 7 5 number:4 weight:7
7.输出n个元素的无重复的全排列。N个元素有n！种不同排列
8.任何一个正整数都可以用2的幂次方表示.例如：137=2^7+2^3+2^0。同时约定次方用括号来表示，即a^b可表示为a(b)。由此可知，137可表示为：2(7)+2(3)+2(0)，进一步：7=2^2+2+2^0 (2^1用2表示)；3=2+2^0；所以最后137可表示为：2(2(2)+2+2(0))+2(2+2(0))+2(0)。又如：1315=2^10+2^8+2^5+2+1；所以1315最后可表示：2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)
输入：正整数(n≤20000)
输出：符合约定的n的0，2表示(在表示中不能有空格)
9.。一个正整数的数字的乘积N的定义是：这个整数中非零数字的乘积。例如，整数999的数字乘积为9*9*9，即729。729的数字乘积为7*2*9，即126。126的数字乘积为1*2*6，即12。12的数字乘积为1*2，即2。一个正整数的数字乘积根N是这样得到的：反复取该整数的数字乘积，直到得到一位数字为止。例如，在上面的例子中数字的乘积根是2。
编写一个程序，输入一个正整数（长度不超过200位数字），输出计算其数字乘积根的每一步结果。
10.输入N个字符，然后以倒序输出（用递归实现）

⑦ pascal语言：用”递归算法”求2个自然数的最大公约数与最小公倍数

{
不是整数的2b数据别给啊

}

var
a,b:longint;
function gcd(a,b:longint):longint; //（递归）最大公约数
begin
if b=0 then gcd:=a
else gcd:=gcd(b,a mod b);
end;
begin
readln(a,b);
writeln('GCD=',gcd(a,b),' ACM=',a*b div gcd(a,b)); //a*b div gcd(a,b)为最小公倍数
end.

⑧ PASCAL 2的幂次方 递归算法

不要求高精的话2的幂用shl（左移）运算最快

你是不是想要用快速幂
function f(x:longint):qword;
var
a:qword;
begin
if x=1 then f:=2 else
begin
a:=f(x div 2);
f:=a*a*(x mod 2+1)
end;
end;

⑨ 哪位高手给我讲一下pascal递归与回朔

一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。因此，在考虑使用递归算法编写程序时，应满足两点：1）该问题能够被递归形式描述；2）存在递归结束的边界条件。
递归的能力在于用有限的语句来定义对象的无限集合。用递归思想写出的程序往往十分简洁易懂。

[例2] 给出一棵二叉树的中序与后序排列。求出它的先序排列。
[分析] 通过对比二叉树的中序与后序排列，我们可以找出根节点及左右子树。同样的，有可以通过对比左子树的中序与后序排列，找出左子树的根节点……可见，该问题能够被递归描述。当找到最后一个根节点时，递归无法再进行下去，这就是递归结束的边界条件。由此可见，递归算法中常常隐含了分治思想。程序如下：
program chu01_3;
var z,h: string;
procere find(a,b:string);
var
s,l : integer;
begin
l:=length(b);
if l=1 then Write(b) {边界条件及递归返回段}
else
begin {递归前进段}
Write(b[l]);
s:=pos(b[l],a);
if s-1>0 then find((a,1,s-1),(b,1,s-1)); {递归左子树}
if l-s>0 then find((a,s+1,l-s),(b,s,l-s)); {递归右子树}
end;
end;
begin
Readln(z);
Readln(h);
Find(z,h);
Readln;
end.
[递归的应用]

1.经典递归
例如hanoi塔问题：经典的递归，原问题包含子问题。有些问题或者数据结构本来就是递归描述的，用递归做很自然。

2.递归与递推
利用递归的思想建立递推关系，如由兔子生崽而来的fibonacci数列。但递推由于没有返回段，因此更为简单，有时可以直接用循环实现。

3.分治
不少分治方法是源于递归思想，或是递归分解+合并处理。

4.回溯
规模较小的问题用回溯解决比较自然。注意递归前后要保证现场的保存和恢复，即正确的转化问题。

5.动态规划
动态规划的子问题重叠性质与递归有某种相似之处。递归+动态修改查表是一种不错的建立动态规划模型的方法。

6.其他
其他么，就是不好归类。例如表达式处理，排列组合等。附带说一下，用递归来处理打印方案的问题还是很方便的。

[例3] 求把一个整数n无序划分成k份互不相同的正整数之和的方法总数。
[分析] 这是一道动态规划题，动态方程如下：
f[i-1,j]+f[i,j-i]+1 （(j mod i=0) and (j div i=1)）
f[i,j]:= f[i-1,j] (i>=j)
f[i-1,j]+f[i,j-i] （else）
s:=f(k,n-k)
本题可以用循环来实现递推,也可以考虑用递归求解。主过程如下：

方案一：
Procere work(I,j:longint; var s:longint);
Var t:longint;
Begin
If (i=1) or (j=1) then s:=1
Else if (i=0) or (j=0) then s:=0
Else begin
if (j mod i=0) and (j div i=1) then
begin
work(i-1,j,s);
t:=s;
work(i,j-1,s);
s:=s+t+1;
end
else if (i>=j) then
work(i-1,j)
else begin
work(i-1,j,s);
t:=s;
work(I,j-1,s);
s:=s+t;
end;
End;

方案二：procere search(v,w,last:byte);
var i:byte;
begin
if w=0 then inc(count)
else
if w=1 then
if v>=last then search(0,0,0) else
else for i:=last to v-1 do search(v-i,w-1,i);
end;

可以看出，方案一的程序较为冗长，消耗栈空间较大；而方案二较为简洁明了，所用的栈空间也较小，效率较高。因此，使用递归算法也有一个优化问题。算法的简洁与否直接制约了程序的可行性和效率。

[总结]
递归使一些复杂的问题处理起来简单明了，尤其在学习算法设计、数据结构时更能体会到这一点。但是，递归在每一次执行时都要为局部变量、返回地址分配栈空间，这就降低了运行效率，也限制了递归的深度。因此，在必要的时候可以只使用递归的思想来求解，而程序则转用非递归的方式书写。

回溯法也称为试探法，该方法放弃关于问题规模大小的限制，并将问题的方案按某种顺序逐一枚举和试验。发现当前方案不可能有解时，就选择下一个方案，倘若当前方案不满足问题的要求时，继续扩大当前方案的规模，并继续试探。如果当前方案满足所有要求时，该方案就是问题的一个解。在回溯中，放弃当前方案，寻找下一介方案的过程称为回溯，
在一般情况下需要用计算机解决的问题有两种类型：
1、 以用精确的数学公式或明确的算法语言来描述的问题。如圆周率的计算、多位数的阶乘等。
2、 完成一件事情的过程中，要经过若干个步骤，而每一个步骤都有若干种可能的分支，为了圆满地完成任务，必须遵守一些规则，但这些规则又无法精确地用数学公式或语言来描述的。
对于第二类问题，一般采用穷举或回溯的方法来解决。穷举法是将问题的所有可能性都一一例举出来，而回溯是穷举算法的一种控制策略，是把有可能圆满地完成任务的解法进行例举，是一种组织得井井有条的，能避免不必要的穷举搜索算法。它的基本思想是：在搜索过程中，由于方案在当前状态下求解不到，需返回搜索进程中的上一环节，并重新寻求解答。
如何学会用回溯的方法解题，先来看下题用穷举法是如何解题的：我们为了便于对问题进一步分析，以下题为例（皇后问题）：
问题描述：在一个4×4的棋盘上放置4个皇后，并使她们不能互相攻击，既在同一个行，同一个列上，同一个对角线不能有多于一个以上的皇后,问有多少种放置的方法。
穷举法：
列出4个皇后在棋盘上的所有可能性，然后一一判断是否互相攻击，程序如下
回溯法：
在寻找解答时需要一个环节一个环节地考虑，当某一个环节的各个方案都已试验过但仍未找到合适的解，得退到上一个环节，对未有试探过的方案继续试探，程序如下：
program qi16;
var
i,t,an:word;
co,bo:boolean;
a:array[1..4] of byte;
const
n=4;ct=4;
begin
t:=0;an:=0;
repeat
inc(t); a[t]:=0;
repeat
inc(a[t]);
bo:=false;
co:=false;
if a[t]>ct then bo:=true
else begin
co:=true;
for i:=t-1 downto 1 do {与已放了皇后的行逐行比较}
if (t-i=abs(a[t]-a[i])) or (a[t]=a[i]) then
co:=false;
end;
if bo then begin dec(t); {如果各个方案都已试验过但仍未找到合适的解则回溯}
if t=0 then co:=true;
end;
until co;
if t>=n then
begin {输出结果}
inc(an);
write('#',an,' ':10);
for i:=1 to n do write(chr(64+i),':',a[i],' ');
writeln
end
until t=0;
if an=0 then writeln('No Answer');
end.

⑩ 在PASCAL语言中，该如何理解递归这一过程

1.概念
一个过程(或函数)直接或间接调用自己本身,这种过程(或函数)叫递归过程(或函数).
如:
procere
a;
begin
.
.
.
a;
.
.
.
end;
这种方式是直接调用.
又如:
procere
b;
procere
c;
begin
begin
.
.
.
.
.
.
c;
b;
.
.
.
.
.
.
end;
end;
这种方式是间接调用.
例1计算n!可用递归公式如下:
1
当
n=0
时
fac(n)={n*fac(n-1)
当n>0时
可编写程序如下:
program
fac2;
var
n:integer;
function
fac(n:integer):real;
begin
if
n=0
then
fac:=1
else
fac:=n*fac(n-1)
end;
begin
write('n=');readln(n);
writeln('fac(',n,')=',fac(n):6:0);
end.

例2
楼梯有n阶台阶,上楼可以一步上1阶,也可以一步上2阶,编一程序计算共有多少种不同的走法.
设n阶台阶的走法数为f(n)
显然有
1
n=1
f(n)={2
n=2
f(n-1)+f(n-2)
n>2
可编程序如下：
program
louti;
var
n:integer;
function
f(x:integer):integer;
begin
if
x=1
then
f:=1
else
if
x=2
then
f:=2
else
f:=f(x-1)+f(x-2);
end;
begin
write('n=');read(n);
writeln('f(',n,')=',f(n))
end.
2.2
如何设计递归算法
1.确定递归公式
2.确定边界(终了)条件
练习:
用递归的方法完成下列问题
1.求数组中的最大数
2.1+2+3+...+n
3.求n个整数的积
4.求n个整数的平均值
5.求n个自然数的最大公约数与最小公倍数
6.有一对雌雄兔,每两个月就繁殖雌雄各一对兔子.问n个月后共有多少对兔子?
7.已知:数列1,1,2,4,7,13,24,44,...求数列的第
n项.
2.3典型例题
例3
梵塔问题
如图:已知有三根针分别用1,2,3表示,在一号针中从小放n个盘子,现要求把所有的盘子
从1针全部移到3针,移动规则是:使用2针作为过度针,每次只移动一块盘子,且每根针上
不能出现大盘压小盘.找出移动次数最小的方案.
程序如下:
program
fanta;
var
n:integer;
procere
move(n,a,b,c:integer);
begin
if
n=1
then
writeln(a,'--->',c)
else
begin
move(n-1,a,c,b);
writeln(a,'--->',c);
move(n-1,b,a,c);
end;
end;
begin
write('Enter
n=');
read(n);
move(n,1,2,3);
end.
例4
快速排序
快速排序的思想是:先从数据序列中选一个元素,并将序列中所有比该元素小的元素都放到它的右边或左边,再对左右两边分别用同样的方法处之直到每一个待处理的序列的长度为1,
处理结束.
程序如下:
program
kspv;
const
n=7;
type
arr=array[1..n]
of
integer;
var
a:arr;
i:integer;
procere
quicksort(var
b:arr;
s,t:integer);
var
i,j,x,t1:integer;
begin
i:=s;j:=t;x:=b[i];
repeat
while
(b[j]>=x)
and
(j>i)
do
j:=j-1;
if
j>i
then
begin
t1:=b[i];
b[i]:=b[j];b[j]:=t1;end;
while
(b[i]<=x)
and
(i<j)
do
i:=i+1;
if
i<j
then
begin
t1:=b[j];b[j]:=b[i];b[i]:=t1;
end
until
i=j;
b[i]:=x;
i:=i+1;j:=j-1;
if
s<j
then
quicksort(b,s,j);
if
i<t
then
quicksort(b,i,t);
end;
begin
write('input
data:');
for
i:=1
to
n
do
read(a[i]);
writeln;
quicksort(a,1,n);
write('output
data:');
for
i:=1
to
n
do
write(a[i]:6);
writeln;
end.
练习:
1.计算ackerman函数值:
n+1
m=0
ack(m,n)={
ack(m-1,1)
m<>0
,n=0
ack(m-1,ack(m,n-1))
m<>0,n<>0
求ack(5,4)