方案-计算对数的程序SICP ex 3.17-我的解决方案正确吗？

问题描述

我需要设计一个过程，该过程返回任何结构中不同对的数量。我的程序正确吗？我在网上找到的解决方案完全不同。

(define (count-pairs x)
  (define (count-cdr x)
    (if (not (pair? x))
        0
        (+ (count-pairs (car x))
           (count-cdr (cdr x)))))
  (if (not (pair? x))
      0
      (+ (count-pairs (car x))
         (count-cdr (cdr x))
         1)))

解决方法

请注意，该问题要求的是 any 结构中的 distinct 对的数量，因此我们必须小心并避免对同一对进行多次计数，即使它在结构中的其他位置！还要注意提示：

遍历该结构，维护一个辅助数据结构，该结构用于跟踪已经对的对进行计数

您必须跟踪找到的对，并检查是否重复，您的解决方案完全忽略了提示。这对我有用：

(define (count-pairs x)
  (let ((acc '()))
    (define (count lst)
      (cond ((or (not (pair? lst)) (memq lst acc)) 0)
            (else (set! acc (cons lst acc))
                  (+ 1 (count (car lst)) (count (cdr lst))))))
    (count x)))

下面是一些测试证明了我的观点：

(define l1 (cons 1 (cons 2 (cons 3 null))))

(define x1 (cons null null))
(define y1 (cons x1 x1))
(define l2 (cons y1 null))

(define x2 (cons 1 (cons 2 null)))
(define l3 (cons x2 x2))

(define x3  (cons null null))
(define y3  (cons x3 x3))
(define l4 (cons y3 y3))

(count-pairs l1)
=> 3
(count-pairs l2)
=> 3
(count-pairs l3)
=> 3
(count-pairs l4)
=> 3

,

在Scheme中，这是我认为很自然的方法。尽管人们（尤其是我）很着迷于使过程变得迭代而不是递归（因为为什么堆栈空间比该代码创建的潜在庞大议程更有价值？），但是为这种程序编写迭代程序还是很不错的东西。

此功能保留两个列表：

• 它已经看到过的配对列表，因此它可以知道是否看到过一对。
• 需要处理的事情的议程，在处理汽车之前，它会将看到的新对的cdr推送到该议程上。

然后，该过程将检查它正在查看的东西是否是一对并且没有被看到。如果这是真的，那么它将对计数加一并处理该对的汽车，将cdr推入议程，并将整个对推入可见列表。如果那不是真的，那么它要么将某些事情从议程中拉出来进行处理，要么，如果没有议程，则它已经完成并且计数就是答案。

请注意，在现实生活中，cp-loop将被命名为let，这使迭代更加清晰。

(define (count-pairs thing)
  (define (cp-loop it count agenda seen)
    (cond
      [(and (pair? it) (not (memq it seen)))
       ;; It's a pair,and we have not seen it,so:
       ;; - add one to the count
       ;; - loop on its car
       ;; - pushing its cdr onto the agenda
       ;; - note we've seen it
       (cp-loop (car it)
                (+ count 1)
                (cons (cdr it) agenda)
                (cons it seen))]
      [(not (null? agenda))
       ;; Either it is not a pair,or we've seen it
       ;; But there is more to do,so:
       ;; - pick the first agenda item & try that
       (cp-loop (first agenda)
                count
                (rest agenda)
                seen)]
      [else
       ;; it's not a pair or we have seen it
       ;; and there is no agenda: we are done
       count]))
  (cp-loop thing 0 '() '()))

现在：

> (define o1 '(1 . (2 . (3 . ()))))
> o1
'(1 2 3)
> (count-pairs o1)
3
> (define o2 '(1 . (2 . (3 . (4 . 5)))))
> o2
'(1 2 3 4 . 5)
> (count-pairs o2)
4
> (define o3 (cons o1 o1))
> (count-pairs o3)
4
> o3
'((1 2 3) 1 2 3)
> (count-pairs '((1 2 3) 1 2 3))
7