Teach Yourself Scheme in Fixnum Days 6 recursion递归
A procedure body can contain calls to other procedures, not least itself:
(define factorial
(lambda (n)
(if (= n 0) 1
(* n (factorial (- n 1))))))
This recursive procedure calculates the factorial of a number. If the number is 0
, the answer is 1
. For any other number n
, the procedure uses itself to calculate the factorial of n ‑ 1
, multiplies that subresult by n
, and returns the product.
Mutually recursive procedures are also possible. The following predicates for evenness and oddness use each other:
相互递归:
(define is-even?
(lambda (n)
(if (= n 0) #t
(is-odd? (- n 1))))) (define is-odd?
(lambda (n)
(if (= n 0) #f
(is-even? (- n 1)))))
These definitions are offered here only as simple illustrations of mutual recursion. Scheme already provides the primitive predicates even?
and odd?
.
6.1 letrec
If we wanted the above procedures as local variables, we could try to use alet
form:
(let ((local-even? (lambda (n)
(if (= n 0) #t
(local-odd? (- n 1)))))
(local-odd? (lambda (n)
(if (= n 0) #f
(local-even? (- n 1))))))
(list (local-even? 23) (local-odd? 23)))
This won’t quite work, because the occurrences of local‑even?
and local‑odd?
in the initializations don’t refer to the lexical variables themselves. Changing the let
to a let*
won’t work either, for while the local‑even?
inside local‑odd?
’s body refers to the correct procedure value, thelocal‑odd?
in local‑even?
’s body still points elsewhere.
To solve problems like this, Scheme provides the form letrec
:
(letrec ((local-even? (lambda (n)
(if (= n 0) #t
(local-odd? (- n 1)))))
(local-odd? (lambda (n)
(if (= n 0) #f
(local-even? (- n 1))))))
(list (local-even? 23) (local-odd? 23)))
The lexical variables introduced by a letrec
are visible not only in theletrec
-body but also within all the initializations. letrec
is thus tailor-made for defining recursive and mutually recursive local procedures.
letrec专门用来定义为定义递归和相互递归的局部过程使用。
6.2 Named let
A recursive procedure defined using letrec
can describe loops. Let’s say we want to display a countdown from 10
:
(letrec ((countdown (lambda (i)
(if (= i 0) 'liftoff
(begin
(display i)
(newline)
(countdown (- i 1)))))))
(countdown 10))
This outputs on the console the numbers 10
down to 1
, and returns the result liftoff
.
Scheme allows a variant of let
called named let
to write this kind of loop more compactly:
scheme有一个named let可以让let有一个名字。
(let countdown ((i 10))
(if (= i 0) 'liftoff
(begin
(display i)
(newline)
(countdown (- i 1)))))
Note the presence of a variable identifying the loop immediately after thelet
. This program is equivalent to the one written with letrec
. You may consider the named let
to be a macro (chap 8) expanding to the letrec
form.
现在变量名countdown立即表示了整个loop,等价于上面用letrec的。
6.3 Iteration
countdown
defined above is really a recursive procedure. Scheme can define loops only through recursion. There are no special looping or iteration constructs.
schemem只能通过递归来定义循环,没有loop或其他的循环购置。
Nevertheless, the loop as defined above is a genuine loop, in exactly the same way that other languages bill their loops. Ie, Scheme takes special care to ensure that recursion of the type used above will not generate the procedure call/return overhead.
Scheme does this by a process called tail-call elimination. If you look closely at the countdown
procedure, you will note that when the recursive call occurs in countdown
’s body, it is the tail call, or the very last thing done — each invocation of countdown
either does not call itself, or when it does, it does so as its very last act. To a Scheme implementation, this makes the recursion indistinguishable from iteration. So go ahead, use recursion to write loops. It’s safe.
Here’s another example of a useful tail-recursive procedure:
(define list-position
(lambda (o l)
(let loop ((i ) (l l))
(if (null? l) #f
(if (eqv? (car l) o) i
(loop (+ i ) (cdr l)))))))
list‑position
finds the index of the first occurrence of the object o
in the list l
. If the object is not found in the list, the procedure returns #f
. list-position找出list表l中对象o第一次出现的位置。
Here’s yet another tail-recursive procedure, one that reverses its argument list “in place”, ie, by mutating the contents of the existing list, and without allocating a new one:
通过改变(mutate)存在的list,不用分配内存:
(define reverse!
(lambda (s)
(let loop ((s s) (r '()))
(if (null? s) r
(let ((d (cdr s)))
(set-cdr! s r)
(loop d s))))))
(reverse!
is a useful enough procedure that it is provided primitively in many Scheme dialects, eg, MzScheme and Guile.)
For some numerical examples of recursion (including iteration), see Appendix C.
1
2
3
4
5
6
7
8
9
10
11
12
|
scheme@(guile-user) > (define list - reverse ... ( lambda (ls) ... ( let loop ((ls ls) (xs '())) ... ( if (null? ls) ... xs ... ( loop ( cdr ls) ... (cons ( car ls) xs)))))) scheme@(guile-user) > (define ls '(1 2 3 4)) scheme@(guile-user) > ( list - reverse ls) (4 3 2 1) scheme@(guile-user) > ls (1 2 3 4) |
6.4 Mapping a procedure across a list
A special kind of iteration involves repeating the same action for each element of a list. Scheme offers two procedures for this situation: map
andfor‑each
.
The map
procedure applies a given procedure to every element of a given list, and returns the list of the results. Eg,
(map add2 '(1 2 3))
=> (3 4 5)
The for‑each
procedure also applies a procedure to each element in a list, but returns void. The procedure application is done purely for any side-effects it may cause. Eg,
for-each 函数主要是为了得到函数的副作用:
(for-each display
(list 1 2 3))
输出:1 2 3
如果用map会输出:
123(#<void> #<void> #<void>) (Racket下)
has the side-effect of displaying the strings (in the order they appear) on the console.
The procedures applied by map
and for‑each
need not be one-argument procedures. For example, given an n
-argument procedure, map
takes n
lists and applies the procedure to every set of n
of arguments selected from across the lists. Eg,
map和for-each的存储过程参数不必是一个参数的存储过程,可以是n个。
(map cons '(1 2 3) '(10 20 30))
=> ((1 . 10) (2 . 20) (3 . 30)) (map + '(1 2 3) '(10 20 30))
=> (11 22 33)
参考:http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-8.html
http://lispor.is-programmer.com/posts/23255.html
Teach Yourself Scheme in Fixnum Days 6 recursion递归的更多相关文章
- Teach Yourself Scheme in Fixnum Days 13 Jump跳转
Jumps One of the signal features of Scheme is its support for jumps or nonlocal control. Specificall ...
- recursion 递归以及递归的缺点
递归定义的算法有两部分: 递归基:直接定义最简单情况下的函数值: 递归步:通过较为简单情况下的函数值定义一般情况下的函数值. 应用条件与准则: (1)问题具有某种可借用的类同自身的子问题描述的性质: ...
- string formating字符串格式化,function函数,group组,recursion递归,练习
# -*- coding: UTF-8 -*- msg = 'i am {} my hobby is {}'.format('lhf',18) print(msg) msg1 = 'i am %s m ...
- Recursion递归
/*java.lang 核心包 如 String Math Integer System Thread等 拿来直接用 * java.awt 窗口工具 GUI * java.net 网络包 * java ...
- Github上的1000多本免费电子书重磅来袭!
Github上的1000多本免费电子书重磅来袭! 以前 StackOverFlow 也给出了一个免费电子书列表,现在在Github上可以看到时刻保持更新的列表了. 瞥一眼下面的书籍分类目录,你就能 ...
- Github 的一个免费编程书籍列表
Index Ada Agda Alef Android APL Arduino ASP.NET MVC Assembly Language Non-X86 AutoHotkey Autotools A ...
- Lisp语言学习的书
Scheme <How to Design Programs : An Introduction to Programming and Computing>(<程序设计方法>) ...
- racket学习-call/cc (let/cc)
Drracket continuation 文中使用let/cc代替call/cc Racket文档中,let/cc说明为: (let/cc k body ...+) Equivalent to (c ...
- 开始学习Scheme
开始学习Scheme 函数式编程(Functional Programming)是在MIT研究人工智能(Artificial Intelligence)时发明的,其编程语言为Lisp.确切地说,L ...
随机推荐
- ACM2039_三角形三边关系
#include <iostream> using namespace std; int main(int argc, char* argv[]) { double a,b,c; int ...
- ios9邮箱添加163邮箱
电脑登陆163邮箱➡️设置➡️开启pop3/smtp/imap功能➡️保存.开启后系统会给你个"客户端授权密码",同时会发短信到你手机里. 打开手机,设置➡️邮件,通讯录,日历➡️ ...
- ubuntu配置bridge网桥
先安装uml-utilities,该工具包含建立虚拟网络设备(所谓的“TAP interfaces”)的工具: sudo apt-get install uml-utilities 安装 桥接工具 b ...
- spring mvc json 返回乱码问题解决(vestion:3.x.x)
本文是转载文章,感觉比较好,如有侵权,请联系本人,我将及时删除. 原文网址:<spring mvc json 返回乱码问题解决(vestion:3.x.x)> 工程中用springmvc返 ...
- XAMPP的MYSQL无法启动
昨天用各种方式试验MYSQL的数据库备份与恢复操作,恢复过程中,MYSQL就无法启动了. 提示如下: 22:59:43 [mysql] Attempting to start MySQL app... ...
- Oracle_表数据拆分与合并
参考文档: [1]http://blog.itpub.net/8858072/viewspace-426960/ [2]http://blog.csdn.net/mattlinsheep/articl ...
- Sequence(组合数学,集合不同元素的个数)
Sequence [组合数学] 时间限制: 3 Sec 内存限制: 128 MB 提交: 138 解决: 52 [提交][状态][讨论版] 题目描述 在某个夜黑月高的晚上,!!!,原谅我编不下去了 ...
- Javascript 精髓整理篇之三(数组篇)postby:http://zhutty.cnblogs.com
今天讲js的数组.数组是js中最基础的数据结构了. 主要讲讲数组实现栈,队列以及其他的基本操作.栈和队列都可以在数组头尾位置处理,所以,都有两种方式. 属性 1.length : 长度,表示数组元素的 ...
- xml的加密和解密
xml加密(XML Encryption)是w3c加密xml的标准.这个加密过程包括加密xml文档的元素及其子元素,通过加密,xml的初始内容将被替换,但其xml格式仍然被完好的保留. 介绍我们有3个 ...
- ArrayList 学习笔记
接口 ArrayList实现了List接口,因此可以当作一个List来使用. 此外,ArrayList还实现RandomAccess接口和Serializable,说明ArrayList支 ...