重复

简介

本章中我会介绍重复。通过重复，你可以编写“通常的”程序。虽然也可以使用do表达式，但Scheme中通常通过递归实现重复。

递归

在自己的定义中调用自己的函数叫做递归函数（Recursive Function）。虽然这听起来很奇怪，但是循环的常见方法。如果你把函数类比为机器的话，递归似乎毫无道理。然而，正因为函数是过程，函数调用自己是有意义的。比如说，让我们来考察一下文献调研吧。你可能需要去阅读你正在阅读的文献所引用的文献（cited-1）。进一步，你可能还需要去阅读文件（cite-1）所引用的其它文献。这样，文献调研就是一个递归的过程，你也可以重复这个调研过程直到满足了特定条件（比如说，你累了）。这样，将程序设计语言中的函数类比为人类活动（比如文献调研）将有助于理解递归函数。

我们通常使用计算阶乘来解释递归。

  1. (define (fact n)
  2.   (if (= n 1)
  3.       1
  4.       (* n (fact (- n 1)))))

(fact 5)的计算过程如下：

  1. (fact 5)
  2. ⇒ 5 * (fact 4)
  3. ⇒ 5 * 4 * (fact 3)
  4. ⇒ 5 * 4 * 3 * (fact 2)
  5. ⇒ 5 * 4 * 3 * 2 * (fact 1)
  6. ⇒ 5 * 4 * 3 * 2 * 1
  7. ⇒ 5 * 4 * 3 * 2
  8. ⇒ 5 * 4 * 6
  9. ⇒ 5 * 24
  10. ⇒ 120

(fact 5)调用(fact 4)，(fact 4)调用(fact 3)，最后(fact 1)被调用。(fact 5)，(fact 4)……以及(fact 1)都被分配了不同的存储空间，直到(fact (- i 1))返回一个值之前，(fact i)都会保留在内存中，由于存在函数调用的开销，这通常会占用更多地内存空间和计算时间。

然而，递归函数可以以一种简单的方式表达重复。表是被递归定义的，进而表和递归函数可以很好地配合。例如，一个让表中所有元素翻倍的函数可以像下面这样写。如果参数是空表，那么函数应该停止计算并返回一个空表。

  1. (define (list*2 ls)
  2.   (if (null? ls)
  3.       '()
  4.       (cons (* 2 (car ls))
  5.              (list*2 (cdr ls)))))

练习1

用递归编写下面的函数。

  1. 用于统计表中元素个数的my-length函数。（length是一个预定义函数）。
  2. 一个求和表中元素的函数。
  3. 一个分别接受一个表ls和一个对象x的函数，该函数返回从ls中删除x后得到的表。
  4. 一个分别接受一个表ls和一个对象x的函数，该函数返回x在ls中首次出现的位置。索引从0开始。如果x不在ls中，函数返回#f。

尾递归

普通的递归调用并不高效因为它既浪费存储空间又具有函数调用开销。与之相反，尾递归函数包含了计算结果，当计算结束时直接将其返回。特别地，由于Scheme规范要求尾递归调用转化为循环，因此尾递归调用就不存在函数调用开销。

[代码片段2]展示了[代码片段1]中函数fact的尾递归版本。

  1. (define (fact-tail n)
  2.   (fact-rec n n))
  4. (define (fact-rec n p)
  5.   (if (= n 1)
  6.       p
  7.       (let ((m (- n 1)))
  8.     (fact-rec m (* p m)))))

fact-tail计算阶乘的过程像这样：

  1. (fact-tail 5)
  2. ⇒ (fact-rec 5 5)
  3. ⇒ (fact-rec 4 20)
  4. ⇒ (fact-rec 3 60)
  5. ⇒ (fact-rec 2 120)
  6. ⇒ (fact-rec 1 120)
  7. ⇒ 120

因为fact-rec并不等待其它函数的计算结果，因此当它计算结束时即从内存中释放。计算通过修改fact-rec的参数来演进，这基本上等同于循环。如上文所述，Scheme将尾递归转化为循环，Scheme就无需提供循环的语法来实现重复。

练习2

用尾递归编写下面的函数

  1. 用于翻转表元素顺序的my-reverse函数。（reverse函数是预定义函数）
  2. 求和由数构成的表。
  3. 将一个代表正整数的字符串转化为对应整数。例如，”1232”会被转化为1232。不需要检查不合法的输入。提示，字符到整数的转化是通过将字符#\0……#\9的ASCII减去48，可以使用函数char->integer来获得字符的ASCII码。函数string->list可以将字符串转化为由字符构成的表。

命名let

命名let（named let）可以用来表达循环。[代码片段3]中的函数fact-let展示了如何使用命名let来计算阶乘。fact-let函数使用了一个命名let表达式(loop)，这与在[代码片段2]中展示的fact-rec函数是不同的。在被注释为;1的那行，代码将参数n1和p都初始化为n。再每次循环后，参数在被注释为;2的那行更新：将n1减1，而将p乘以(n1 - 1)。

在Scheme中，用命名let来表达循环是俗成的方法。

  1. (define (fact-let n)
  2.   (let loop((n1 n) (p n))           ; 1
  3.     (if (= n1 1)                    
  4.     p
  5.     (let ((m (- n1 1)))
  6.       (loop m (* p m))))))      ; 2

练习3

用命名let编写下面的函数。

  1. 练习1的问题3和问题4；
  2. 练习2中的函数；
  3. range函数：返回一个从0到n的表（但不包含n）。

letrec

letrec类似于let，但它允许一个名字递归地调用它自己。语法letrec通常用于定义复杂的递归函数。[代码片段4]展示了fact函数的letrec版本。

  1. (define (fact-letrec n)
  2.   (letrec ((iter (lambda (n1 p)
  3.            (if (= n1 1)
  4.                p
  5.                (let ((m (- n1 1)))
  6.              (iter m (* p m)))))))     ; *
  7.     (iter n n)))

正如被注释为;*的那行代码所示，局部变量iter可以在它的定义里面引用它自己。语法letrec是定义局部变量的俗成方式。

练习4

用letrec重写练习2。

do表达式

虽然并不常见，但语法do也可用于表达重复。它的格式如下：

  1. (do binds (predicate value)
  2.     body)

变量在binds部分被绑定，而如果predicate被求值为真，则函数从循环中逃逸（escape）出来，并返回值value，否则循环继续进行。

binds部分的格式如下所示：

  1. [binds] → ((p1 i1 u1) (p2 i2 u2) ... )

变量p1，p2，…被分别初始化为i1，i2，…并在循环后分别被更新为u1，u2，…。

[代码片段5]演示了fact的do表达式版本。

  1. (define (fact-do n)
  2.   (do ((n1 n (- n1 1)) (p n (* p (- n1 1)))) ((= n1 1) p)))

变量n1和p分别被初始化为n和n，在每次循环后分别被减去1和乘以(n1 - 1)。当n1变为1时，函数返回p。

我认为do比命名let还要复杂一些。

练习5

用do表达式重写练习2。

小结

现在你可以用我讲解过的技巧来编写常见程序了。通常来说，命名let用于编写简单的循环，而letrec则是用来写复杂的局部递归函数。

下一章中我讲讲解高阶函数。高阶函数使得你的代码更加“Scheme风味”。

习题解答

练习1

  1. ; 1
  2. (define (my-length ls)
  3.   (if (null? ls)
  4.       0
  5.       (+ 1 (my-length (cdr ls)))))
  7. ; 2
  8. (define (my-sum ls)
  9.   (if (null? ls)
  10.       0
  11.       (+ (car ls) (my-sum (cdr ls)))))
  13. ; 3
  14. (define (remove x ls)
  15.   (if (null? ls)
  16.       '()
  17.       (let ((h (car ls)))
  18.         ((if (eqv? x h)
  19.             (lambda (y) y)
  20.             (lambda (y) (cons h y)))
  21.          (remove x (cdr ls))))))
  23. ; 4
  24. (define (position x ls)
  25.   (position-aux x ls 0))
  27. (define (position-aux x ls i)
  28.   (cond
  29.    ((null? ls) #f)
  30.    ((eqv? x (car ls)) i)
  31.    (else (position-aux x (cdr ls) (1+ i)))))

练习2

  1. ; 1
  2. (define (my-reverse ls)
  3.   (my-reverse-rec ls '()))
  5. (define (my-reverse-rec ls0 ls1)
  6.   (if (null? ls0)
  7.       ls1
  8.       (my-reverse-rec (cdr ls0) (cons (car ls0) ls1))))
  10. ;-------------------
  11. ; 2
  12. (define (my-sum-tail ls)
  13.   (my-sum-rec ls 0))
  15. (define (my-sum-rec ls n)
  16.   (if (null? ls)
  17.       n
  18.       (my-sum-rec (cdr ls) (+ n (car ls)))))
  20. ;--------------------
  21. ; 3
  22. (define (my-string->integer str)
  23.   (char2int (string->list str) 0))
  25. (define (char2int ls n)
  26.   (if (null? ls)
  27.       n
  28.       (char2int (cdr ls) 
  29.         (+ (- (char->integer (car ls)) 48)
  30.            (* n 10))))

练习3

  1. ; 1
  2. (define (remove x ls)
  3.   (let loop((ls0 ls) (ls1 ()))
  4.     (if (null? ls0) 
  5.     (reverse ls1)
  6.     (loop
  7.      (cdr ls0)
  8.           (if (eqv? x (car ls0))
  9.               ls1
  10.             (cons (car ls0) ls1))))))
  12. ; 2
  13. (define (position x ls)
  14.   (let loop((ls0 ls) (i 0))
  15.     (cond
  16.      ((null? ls0) #f)
  17.      ((eqv? x (car ls0)) i)
  18.      (else (loop (cdr ls0) (1+ i))))))
  20. ; 3
  21. (define (my-reverse-let ls)
  22.   (let loop((ls0 ls) (ls1 ()))
  23.     (if (null? ls0)
  24.     ls1
  25.     (loop (cdr ls0) (cons (car ls0) ls1)))))
  27. ; 4
  28. (define (my-sum-let ls)
  29.   (let loop((ls0 ls) (n 0))
  30.     (if (null? ls0)
  31.     n
  32.     (loop (cdr ls0) (+ (car ls0) n)))))
  34. ; 5
  35. (define (my-string->integer-let str)
  36.   (let loop((ls0 (string->list str)) (n 0))
  37.     (if (null? ls0)
  38.     n
  39.     (loop (cdr ls0)
  40.           (+ (- (char->integer (car ls0)) 48)
  41.          (* n 10))))))
  43. ; 6
  44. (define (range n)
  45.   (let loop((i 0) (ls1 ()))
  46.     (if (= i n)
  47.         (reverse ls1)
  48.       (loop (1+ i) (cons i ls1)))))

练习4

  1. ; 1
  2. (define (my-reverse-letrec ls)
  3.   (letrec ((iter (lambda (ls0 ls1)
  4.            (if (null? ls0)
  5.                ls1
  6.                (iter (cdr ls0) (cons (car ls0) ls1))))))
  7.     (iter ls ())))
  9. ; 2
  10. (define (my-sum-letrec ls)
  11.   (letrec ((iter (lambda (ls0 n)
  12.            (if (null? ls0)
  13.                n
  14.                (iter (cdr ls0) (+ (car ls0) n))))))
  15.     (iter ls 0)))
  17. ; 3
  18. (define (my-string->integer-letrec str)
  19.   (letrec ((iter (lambda (ls0 n)
  20.            (if (null? ls0)
  21.                n
  22.                (iter (cdr ls0)
  23.                  (+ (- (char->integer (car ls0)) 48)
  24.                 (* n 10)))))))
  25.     (iter (string->list str) 0)))

练习5

  1. ; 1
  2. (define (my-reverse-do ls)
  3.   (do ((ls0 ls (cdr ls0)) (ls1 () (cons (car ls0) ls1)))
  4.       ((null? ls0) ls1)))
  6. ; 2
  7. (define (my-sum-do ls)
  8.   (do ((ls0 ls (cdr ls0)) (n 0 (+ n (car ls0))))
  9.       ((null? ls0) n)))
  11. ; 3
  12. (define (my-string->integer-do str)
  13.   (do ((ls0 (string->list str) (cdr ls0))
  14.        (n 0 (+ (- (char->integer (car ls0)) 48) 
  15.            (* n 10))))
  16.       ((null? ls0) n)))