Question

我试图写一个方法来从BST中删除一个元素。到目前为止，这就是我所拥有的。我不确定我是否在正确的轨道上，或者是否有更好的方法通过使用模式匹配来匹配不同的删除案例，即：没有孩子，1个孩子，2个孩子。

type 'a bst = NL | BinTree of 'a * 'a bst * 'a bst;;

let rec smallest = function
    | NL -> failwith "tree is empty"
    | BinTree(m, lst, rst) -> if lst = NL then BinTree(m, lst, rst)
                              else smallest lst;;

let rec smallest2 = function
    | NL -> failwith "tree is empty"
    | BinTree(m, lst, rst) -> if lst = NL then m
                              else smallest2 lst;;

let rec rem2 = function
    | NL -> NL
    | BinTree(m, NL, NL) -> NL
    | BinTree(m, NL, rst) -> rst
    | BinTree(m, lst, NL) -> lst
    | BinTree(m, lst, rst) -> BinTree(smallest2 rst, lst, rst);;


let rec rem x = function
    |NL -> failwith "Node doesn't exit"
    |BinTree(m, lst, rst) -> if m = x then rem2 (BinTree(m, lst, rst)) 
                             elif m < x then BinTree(m, lst, rem x rst) 
                             else BinTree(m, rem x lst, rst);;

没有孩子和单个孩子的情况完美地工作，但是当要删除的节点有2个孩子时，我无法弄清楚如何实现这种情况。我想用它上面的最小项替换该节点的值，然后删除其右子树中的最小项。

Answer 1

我不太清楚我理解你的remove函数试图实现的逻辑。通常的方法是编写一个递归函数：

如果x小于当前，则以递归方式从左子树中删除x
如果x大于当前值，请以递归方式从rightsub-tree中删除x
如果x等于当前，则删除当前节点并合并两棵树

在F＃中对此进行编码的方法是使用模式匹配编写递归函数 - 与您编写的函数非常相似：

let rec remove x = function
  | NL -> NL
  | BinTree(m, lst, rst) when x = m -> merge lst rst
  | BinTree(m, lst, rst) when x < m -> BinTree(m, remove x lst, rst)
  | BinTree(m, lst, rst) (* x > m *) -> BinTree(m, lst, remove x rst)

[编辑以下内容实际上无法正常工作！]这几乎已经完成，但您需要添加merge功能。合并功能的逻辑如下：

如果两棵树都是空的，则返回空树
如果左侧是Bin(n, llst, lrst)而右侧是rst，则返回一个树，其中包含n左侧llst并且（递归地）合并lrst和rst在右边（因为它们中的元素都大于n）。
同样，如果右边是Bin而左边是其他任何内容。

这不会产生平衡二叉树，但它是一个好的开始。

编辑：我认为最简单的选择可能就是编写两个函数 - 一个用于删除最大的一个函数，另一个用于删除树中的最小元素（然后在合并时，您可以调用一个这两个）。这可能比编写完全通用的删除功能更容易。

以下删除最大元素并将其与新树（没有最大元素）一起返回：

let rec remLargest = function
  | NL -> failwith "Tree was empty!"
  | BinTree(m, l, NL) -> m, l
  | BinTree(m, l, r) -> 
      let res, newR = remLargest r
      res, BinTree(m, l, newR)

Answer 2

我已经按照Tomas在他的帖子中描述的步骤，我想出了这个解决方案：

// BST - binary search tree
type BST<'a when 'a: comparison> = | Leaf
                                   | Node of BST<'a> * 'a * BST<'a>

let rec rmMaxBST = function
    | Leaf              -> failwith "Tree was empty"
    | Node(tL, x, Leaf) -> x, tL
    | Node(tL, x, tR  ) -> let m, newTR = rmMaxBST tR
                           m, Node(tL, x, newTR)

let rec rmMinBST = function
    | Leaf              -> failwith "Tree was empty"
    | Node(Leaf, x, tR) -> x, tR
    | Node(tL,   x, tR) -> let m, newTL = rmMinBST tL
                           m, Node(newTL, x, tR)

let mergeBST t1 t2 =
    match t1, t2 with
    | (Leaf, Leaf)      -> Leaf
    | (t1,   Leaf)      -> let x, t = rmMaxBST t1
                           Node(t, x, Leaf)               
    | (t1,   t2  )      -> let x, t = rmMinBST t2
                           Node(t1, x, t)              

let rec delBST x = function
    | Leaf                       -> Leaf
    | Node(tL, a, tR) when x < a -> Node(delBST x tL, a,          tR)
    | Node(tL, a, tR) when a < x -> Node(         tL, a, delBST x tR)
    | Node(tL, _, tR)            -> mergeBST tL tR

我在REPL中试过这个：

> delBST 3 Leaf;;

val it : BST<int> = Leaf

> delBST 3 (Node(Leaf, 4, Leaf));;

val it : BST<int> = Node (Leaf,4,Leaf)

> delBST 3 (Node(Leaf, 3, Leaf));;

val it : BST<int> = Leaf

> delBST 3 (Node(Node(Leaf, 1, Leaf), 3, Node(Leaf, 5,Leaf)));;

val it : BST<int> = Node (Node (Leaf,1,Leaf),5,Leaf)

> delBST 1 (Node(Node(Leaf, 1, Leaf), 3, Node(Leaf, 5,Leaf)));;

val it : BST<int> = Node (Leaf,3,Node (Leaf,5,Leaf))

> delBST 5 (Node(Node(Leaf, 1, Leaf), 3, Node(Leaf, 5,Leaf)));;

val it : BST<int> = Node (Node (Leaf,1,Leaf),3,Leaf)

从F＃

2 个答案: