如何在Dr.Racket中重新分配值

Question

I am trying to implement Binary Tree in Scheme-Dr.Racket, but i have some trouble with the insert! function.

Here is the source

(define (makeTree leftSubTree root rightSubTree)
  (list leftSubTree root rightSubTree))

(define (subTree part tree)
  (if (null? tree)
      '()
      (part tree)))

(define (root tree)
  (subTree cadr tree))

(define (leftSubTree tree)
  (subTree car tree))

(define (rightSubTree tree)
  (subTree caddr tree))

(define (leaf? tree)
  (and (null? (leftSubTree tree))
       (null? (rightSubTree tree))))

; (define tree (makeTree (makeTree '() 1 '()) 2 (makeTree '() 3 '()))) 

(define (member? tree element)
  (if (null? tree)
      #f
      (or (= (root tree) element)
          (member? (leftSubTree tree) element)
          (member? (rightSubTree tree) element))))

(define (insert! tree element)
  (if (null? tree)
      (set! tree (makeTree '() element '()))
      (if (leaf? tree)
          (cond
            ((> (root tree) element) (set! tree (makeTree (makeTree '() element '()) (root tree) '())))
            ((< (root tree) element) (set! tree (makeTree '() (root tree) (makeTree '() element '()))))
            ((= (root tree) element) '()))
          (cond
            ((= (root tree) element) '())
            ((> (root tree) element) (insert! (leftSubTree tree) element))
            (else  (insert! (rightSubTree tree) element))))))

As far as I know the set! function changes the value of the object id is pointing to or

(set! tree (makeTree '() val '()))

Is going to change the value of tree to a tree with one node - val. Can someone try to explain me why am i wrong?

Answer 1

Your insert! function only ever affects the binding of its own parameter named tree .

When the function returns, its parameters' bindings are destroyed with it.

You want to affect the change to the structure of a memory object your parameter tree refers to. That's not what set! does. It only changes the value of a variable's binding.

In Scheme there's set-car! and set-cdr! primitives for that, but Racket's lists are immutable. Mutable lists are created with mcons , not with cons , nor list . Racket doesn't even have set-car! and friends, and calls them set-mcar! etc. instead, and they don't work on lists created with list .

You could switch your tree representation from lists to structs, using define-struct for that.

Alternatively, choose an appropriate #lang directive to place at the start of your source file, like eg #lang r5rs so set-car! etc. work; or create your lists with mcons so you can use set-mcar! and the like, if working under #lang racket :

> (define y (mcons 1 (mcons 2 '())))
> y
(mcons 1 (mcons 2 '()))
> (set-mcar! y 11)
> y
(mcons 11 (mcons 2 '()))

Answer 2

What is wrong?

Imagine this C-code:

void test (int n) {
  n = 6;
}

int v = 1;
test(v);
printf("%d", v)

Now according to your Scheme code you expect 6 to be the printed value, but that is not what happens. n is a local variable in test in the same manner as tree is a local variable in insert! . When you set! you are not mutating the value but you redirect what the identifier should point to to a new (perhaps unrelated) value. All other bindings point to the same value will still point to the original value since it's the binding n that is changed and not v .

How to fix it

The best is to not mutate at all.

(define (insert tree element)
  (if (tree-empty? tree)
      (make-tree tree-empty element tree-empty)
      (let ((value (tree-value tree))
            (left (tree-left tree))
            (right (tree-right tree)))
        (if (< value element)
            (make-tree (insert left element) value right)
            (make-tree left value (insert right element))))))

You can still replace a binding like this:

(set! root (insert root 2))

You can mutate the nodes.. This makes you tree singleton and you need to handle an empty root specially since you cannot mutate null into a value. A solution can be a special root with a empty indication.

(define tree-left-place values)
(define tree-right-place cddr)
(define tree-value-place cdr)
(define +root-value (list 'root))
(define root (make-tree tree-empty %root-value tree-empty))
(define (insert! tree element)
  (define (insert-helper place)
    (if (tree-empty? (place-value place))
        (set-car! place (make-tree empty-tree element empty-tree))
        (insert! (place-var place) element)))

  (let ((value (tree-value tree)))
    (cond ((eq? value +root-value) (set-car! (tree-value-place tree) element))
          ((< element value) (insert-helper (tree-left-place tree)))
          (else (insert-helper (left-right-place tree))))))