Python 二叉搜索树错误

Question

最近两天我一直在尝试在 python 中实现二叉搜索树。

树节点：

class tree_node:
    def  __init__(self,val,rightChild,leftChild):
        self.val = val
        self.rightChild = rightChild
        self.leftChild = leftChild

二叉搜索树：

class binary_tree:
    def __init__(self,baseNode):
        self.baseNode = baseNode        
    def addTreeNode(self,treeNode):
        current = self.baseNode
        prev = None
        while current:
            prev = current
            if treeNode.val<current.val:
                current = current.rightChild
            elif treeNode.val>current.val:
                current = current.leftChild
        if treeNode.val<prev.val:
            prev.rightChild  = treeNode
        elif treeNode.val>prev.val:
            prev.leftChild = treeNode
    def print_tree(self):
        def dfs(node):
            if node:
                 print("",node.val)
                 dfs(node.rightChild)         
                 dfs(node.leftChild)              
        dfs(self.baseNode)
    def deleteNode(self,treeNode):
        current = self.baseNode
        prev = None
        while current:
            prev = current
            if treeNode.val<current.val:
                current = current.rightChild
                if current == treeNode:
                    break
            elif treeNode.val>current.val:
                current = current.leftChild
                if current == treeNode:
                    break
        if not  current.rightChild and not current.leftChild:
            if current == prev.rightChild:
                prev.rightChild = None
                current = None
            elif current == prev.leftChild:
                prev.leftChild = None
                current = None          
        elif (current.rightChild and not current.leftChild) or (current.leftChild and not current.rightChild):
            if current.val>self.baseNode.val:
                if not current.leftChild:
                    prev.leftChild = current.rightChild
                    current = None
                else:
                    prev.leftChild = current.leftChild
                    current = None
            elif current.val<self.baseNode.val:
                if not current.leftChild:
                    prev.rightChild = current.rightChild
                    current = None
                else:
                    prev.rightChild = current.leftChild
                    current = None
        elif current.rightChild and current.leftChild:
             if  current == prev.rightChild:                
                prev.rightChild = current.rightChild
                prev.rightChild.rightChild = current.leftChild
                current= None                                      
             elif current == prev.leftChild:
                prev.rightChild = current.rightChild
                prev.rightChild.rightChild = current.leftChild
                current = None

我将这些树节点放在二叉搜索树中：

zero = tree_node(0,None,None)
minusone = tree_node(-1,None,None)
one = tree_node(1,None,None)
minustwo = tree_node(-2,None,None)
two= tree_node(2,None,None)
three= tree_node(3,None,None)
minussevenhalves= tree_node(-7/2,None,None)
four= tree_node(4,None,None)
minusfour= tree_node(-4,None,None)
minusfive= tree_node(-5,None,None)
minusonehalf = tree_node(-1/2,None,None)
onehalf = tree_node(1/2,None,None)
six = tree_node(6,None,None)
threehalves = tree_node(3/2,None,None)

bst = binary_tree(zero)
bst.addTreeNode(one)
bst.addTreeNode(two)
bst.addTreeNode(minusonehalf)
bst.addTreeNode(minustwo)
bst.addTreeNode(minusone)
bst.addTreeNode(three)
bst.addTreeNode(minusfive)
bst.addTreeNode(minussevenhalves)
bst.addTreeNode(four)
bst.addTreeNode(minusfour)
bst.addTreeNode(onehalf)
bst.addTreeNode(six)
bst.addTreeNode(threehalves)

我连续打印树并删除一个节点，看看我的代码是否正确：

bst.print_tree()
Output:0
-0.5
-2
-5
-3.5
-4
-1
 1
 0.5
 2
 1.5
 3
 4
 6
print("Removing node with value -2")
bst.deleteNode(minustwo)
bst.print_tree()
Output:0
-0.5
-5
-1
-3.5
-4
 1
 0.5
 2
 1.5
 3
 4
 6
 print("Removing node with value -7/2")
 bst.deleteNode(minussevenhalves)
 bst.print_tree()
 Output:0
 -0.5
 -5
 -4
 -3.5
 -4
  1
  0.5
  2
  1.5
  3
  4
  6
  print("Removing node with value 4")
  bst.deleteNode(four)
  bst.print_tree()
  Output: 0
  -0.5
  -5
  -4
  -3.5
  -4
   1
   0.5
   2
   1.5
   3
   6
  

因此，正如您所见，删除树右侧有 1 个子项的项目时出现问题。

所以我去调查这个问题。我意识到带有 val -1 的节点有 2 个孩子，但是
在尝试使用 val -7/2 删除节点之前，第二个孩子没有出现。这是怎么回事？

Answer 1

我希望这个例子可以帮助您了解问题所在。

以下是如何在 Python 中实现二叉搜索树 (BST) 的示例：

class Node:
 def __init__(self, value):
   self.value = value
   self.left = None
   self.right = None

class BinarySearchTree:
 def __init__(self):
   self.root = None

 def insert(self, value):
   new_node = Node(value)
   if self.root is None:
     self.root = new_node
   else:
     current_node = self.root
     while True:
       if value < current_node.value:
         if current_node.left is None:
            current_node.left = new_node
            break
        current_node = current_node.left
       else:
         if current_node.right is None:
            current_node.right = new_node
            break
         current_node = current_node.right

 def search(self, value):
   current_node = self.root
   while current_node is not None:
     if value == current_node.value:
       return True
     elif value < current_node.value:
       current_node = current_node.left
     else:
       current_node = current_node.right
   return False

BST 的这个实现由两个类组成：Node 和 BinarySearchTree。 节点 class 表示树中的单个节点，具有指向其左右子节点的值和指针。 BinarySearchTree class 表示树本身，具有根节点和用于在树中插入和搜索值的方法。

要使用此实现，您可以创建一个 BinarySearchTree object 并使用插入方法向树中添加值。 您可以使用搜索方法检查树中是否存在值。

例如：

tree = BinarySearchTree()
tree.insert(5)
tree.insert(3)
tree.insert(7)

print(tree.search(5))  # True
print(tree.search(7))  # True
print(tree.search(4))  # False

这将创建一个值为 5、3 和 7 的 BST，并为树中存在的值打印 True，为不存在的值打印 False。