(define(arithvalue T)
  (cond((eq? (arithvalue T) #\+)(+ (arithvalue (left T))
                          (arithvalue (right T))))
       ((eq? (arithvalue T) #\*)(*(arithvalue(left T))
                              (arithvalue(right T))))
       ((eq? (arithvalue T) #\-)(- (arithvalue(left T))))
       ((eq? (arithvalue T) #\/)(/ 1(arithvalue(left T))))
       (else (arithvalue T))))


(define (right tree) (caddr tree))
(define (delete-value v T)
 (define (leaf? T) (and (null? (left T))
                        (null? (right T))))
  (define (tree-max T)  (if (null? (right T))
                            (value T)
                            (max (value T)
                                 (tree-max (right T)))))
  (cond ((null? T) '())
        ((< (value T)) (make-tree (value T)
                                  (delete-value v (left T))
                                  (right T)))
        ((> v (value T)) (make-tree (value T)
                                    (left T)
                                    (delete-value v (right T))))
        ((null? (left T)) (right T))
        (else (make-tree (tree-max (left T))
                         (delete-value (tree-max (left T))
                                 (left T)
                               (right T))))))