Question

我对python中的编程很新，我想用一些实现来创建二进制搜索树。我想要添加的最后一个实现是，当用户选择我的“删除”功能时，无论他们想删除哪个项目，我的功能都会提供最好的数字来替换它。无论是继承者还是前任，为了使我的树平衡。 enter image description here

因此，在此示例中，用户希望删除“30”。那么你会用什么代替呢？我希望我的程序用'24'替换它以使列表更平衡，因为节点'24'与另一侧的'52'相比。但是，它会随机选择一个可以让45个占据我不想要的30个。

这是我的TreeNode类：

class TreeNode(object):

    def __init__(self, data = None, left=None, right=None):
        self.item = data
        self.left = left
        self.right = right

    def __str__(self):
        return str(self.item)

这是我的主要功能，除了我的删除功能和我的计数功能之外我修剪了大部分功能，这可以让我觉得这个过程更容易。

from TreeNode import TreeNode


class BST(object):

    #------------------------------------------------------------

    def __init__(self):

        """create empty binary search tree
        post: empty tree created"""

        self.root = None
        self.size = 0

    def delete(self, item):

        """remove item from binary search tree
        post: item is removed from the tree"""

        self.root = self._subtreeDelete(self.root, item)

    #------------------------------------------------------------

    def _subtreeDelete(self, root, item):

        if root is None:   # Empty tree, nothing to do
            return None
        if item < root.item:                             # modify left
            root.left = self._subtreeDelete(root.left, item)
        elif item > root.item:                           # modify right
            root.right = self._subtreeDelete(root.right, item)
        else:                                            # delete root
            if root.left is None:                        # promote right subtree
                root =  root.right
            elif root.right is None:                     # promote left subtree
                root = root.left
            else:
                # root node can't be deleted, overwrite it with max of 
                #    left subtree and delete max node from the subtree
                root.item, root.left = self._subtreeDelMax(root.left)
        return root

 def _subtreeDelMax(self, root):

        if root.right is None:           # root is the max 
            return root.item, root.left  # return max and promote left subtree
        else:
            # max is in right subtree, recursively find and delete it
            maxVal, root.right = self._subtreeDelMax(root.right)
            return maxVal, root  

 def treeSize(self, root, size = 0):

        if root is None:
            return -1

        if root is not None:
            self.size += 1
            if root.left is not None:
                self.treeSize(root.left, size)
            if root.right is not None:
                self.treeSize(root.right, size)
        return self.size

如果有人可以帮助我如何更改我的删除功能，以使其搜索正确的删除节点。谢谢！

编辑：我不知道这是否有帮助，但这里也是我的测试代码：

from BinarySearchTree import BST
from TreeNode import TreeNode

tree = TreeNode(4, TreeNode(2, TreeNode(1), TreeNode(3)), TreeNode (7, TreeNode(6),TreeNode(9, TreeNode(8), TreeNode(10))))

a = BST()



print("PRE-ORDER TRANSVERSE:")
print(a.preOrder(tree))
print("IN-ORDER TRANSVERSE:")
print(a.inOrder(tree))
print("POST-ORDER TRANSVERSE:")
print(a.postOrder(tree))


print("There are,", a.treeSize(tree),"nodes in this tree.")

所以基本上我的测试需要用'24'代替'30'。

Answer 1

Python不是我的首选语言，因此我不会尝试参与该级别，但在理论层面，我建议您考虑让节点了解每个子树的高度的可能性。

因此，每当你添加一个节点时，你显然会向下移动通过树插入，当你返回树时，你可以有一个值来指示高度是否增加并在每个级别跟踪它。然后当你删除时，你可以很容易地抓住具有最大高度的子树，或者当相等时只是总是拿左边的树（例如）。

二进制搜索树，确定使用Predecessor或Successor来使树平衡

1 个答案: