（修复）racket的代码--从树中删除节点

因此，我目前处于中级水平，已经研究了各种代码，但大多数代码我都搞不清楚 我正在尝试从二叉搜索树中删除一个节点

到目前为止，我已经想到了这个，它包括一个空节点和第一个和最后一个顺序错误的节点

    (define-struct node (key value left right))

    (define (delete bst k)
  (local [(define empty-l (empty? (node-left bst)))
          (define empty-r (empty? (node-right bst)))
          (define full-l (not empty-l))
          (define full-r (not empty-r))]

    (local [(define (replace bst) 
              ;;takes node and takes it away, finding the next part that should take over its spot
              (cond
                [(empty? bst) empty]
                [(and empty-l empty-r) empty]
                [(and empty-l full-r) (node-right bst)]
                [(and full-l empty-r) (node-left bst)]
                [(and full-l full-r) (make-node                                  
                                      (if (**empty? (node-right bst)) "MAKE_THIS_KEY_GO_AWAY"**  (node-key (node-right bst)))
                                      (if (**empty? (node-right bst)) "MAKE_THIS_VALUE_GO_AWAY"** (node-value (node-right bst)))
                                      ;(node-value (node-right bst))
                                      (node-left bst)
                                      (replace (node-right bst)))]))]

      ;(local ((define (find k bst)
      ;;if finds k, puts it through replace to replace it
      (cond
        [(empty? bst) empty]
        [(= k (node-key bst)) (replace bst)]
        [(< k (node-key bst)) (make-node (node-key bst)
                                         (node-value bst)
                                         (delete k (node-left bst))
                                         (node-right bst))]
        [else (make-node (node-key bst)
                         (node-value bst)
                         (node-left bst)
                         (delete k (node-right bst)))]))))

;; Example binary search tree for check-expect
(define t (make-node 5 "" (make-node 3 "" (make-node 2 "" (make-node 1 "" empty empty)
                                                     empty)
                                     (make-node 4 "" empty empty))
                     (make-node 7 "" (make-node 6 "" empty empty) empty)))



(check-expect (delete t 5)
              (**make-node 6 ""** (make-node 3 "" (make-node 2 "" (make-node 1 "" empty empty)
                                                         empty)
                                         (make-node 4 "" empty empty))
                         (**make-node 7 ""** empty empty)))


;;What I actually get
(**make-node
 7
 ""**
 (make-node
  3
  ""
  (make-node
   2
   ""
   (make-node 1 "" empty empty)
   empty)
  (make-node 4 "" empty empty))
 (**make-node
  "MAKE_THIS_KEY_GO_AWAY"
  "MAKE_THIS_VALUE_GO_AWAY"**
  (**make-node 6 ""** empty empty)
  empty))

（定义结构节点（键值左右））
（定义（删除bst k）
（本地[（定义空-l（空）（节点左侧bst）））
（定义empty-r（empty？（节点右侧bst）））
（定义满l（非空l））
（定义满-r（非空-r））]
（本地[（定义（替换bst）
；取下节点并将其取下，找到应接管其位置的下一个零件
（续）
[（空？bst）空]
[（和empty-l empty-r）empty]
[（和空-l满-r）（节点右侧bst）]
[（和full-l empty-r）（节点左侧bst）]
[（和full-l full-r）（生成节点
（如果（**为空？（节点右侧bst））“将此密钥设置为离开”**（节点密钥（节点右侧bst）））
（如果（**为空？（节点右侧bst））“使此值消失”**（节点值（节点右侧bst）））
；（节点值（节点右侧bst））
（节点左bst）
（替换（节点右侧bst）））]
；（本地（（定义（查找bst）
；如果找到k，则通过replace替换它
（续）
[（空？bst）空]
[（=k（节点密钥bst））（替换bst）]
[（

这个

（full-l full-r）

案例完全是一团糟。要处理这个案例，你需要选择维基百科所称的“顺序前置”或“顺序后续”由

replace

处理的

bst

实例，然后从

replace

的

bst

中删除该键并使其成为替换项。这些函数可用于按顺序查找前置/后续项：

(define (in-order-predecessor tree)
  (right-bottom (node-left tree)))

(define (in-order-successor tree)
  (left-bottom (node-right tree)))

(define (left-bottom tree)
  (if (empty? (node-left tree))
      tree
      (left-bottom (node-left tree))))

(define (right-bottom tree)
  (if (empty? (node-right tree))
      tree
      (right-bottom (node-right tree))))

所以你会这样做：

[(and full-l full-r)
 (local [(define successor (in-order-successor bst))
         (define old-right (node-right bst))
         (define new-right (delete old-right (node-key successor)))]
     (make-node (node-key successor) (node-value successor)
                (node-left bst) new-right))]

由于此版本的

replace

不再是递归的，因此不需要将

bst

作为参数接收

此外，您还混淆了

delete

的参数顺序。您将其定义为

（delete node k）

，但在两个地方您将其称为

（delete k node）