二进制搜索树，尝试实现删除节点方法，指针出现问题

Question

我在stackoverflow上找到了另一个不错的线程，可以将它链接起来， 使用递归从二进制搜索树中删除一个节点 。 这是我从中获取代码的地方，它看起来像这样：

import random
from time import time

class BinaryNode:

    def __init__(self, value = None):
        """Create binary node"""
        self.value = value
        self.left = None
        self.right = None

    def add(self, val):
        """Adds a new node to the tree containing this value"""
        if val <= self.value:
            if self.left:
                self.left.add(val)
            else:
                self.left = BinaryNode(val)
        else:
            if self.right:
                self.right.add(val)
            else:
                self.right = BinaryNode(val)

    def delete(self):
        """
         Remove value of self from BinaryTree. Works in conjunction with remove
         method in BinaryTree
        """

        if self.left == self.right == None:
            return None
        if self.left == None:
            return self.right
        if self.right == None:
            return self.left

        child = self.left
        grandchild = child.right
        if grandchild:
            while grandchild.right:
                child = grandchild
                grandchild = child.right
            self.value = grandchild.value
            child.right = grandchild.left
        else:
            self.left = child.left
            self.value = child.value

        return self

class BinaryTree:

    def __init__(self):
        """Create empty binary tree"""
        self.root = None

    def add(self, value):
        """Insert value into proper location in Binary Tree"""
        if self.root is None:
            self.root = BinaryNode(value)
        else:
            self.root.add(value)

    def contains(self, target):
        """Check whether BST contains target value"""

        node = self.root
        while node:
            if target == node.value:
                return True
            if target < node.value:
                node = node.left
            else:
                node = node.right

        return False

    def remove(self, value):
        """Remove value from tree"""

        if self.root:
            self.root = self.removeFromParent(self.root, value)

    def removeFromParent(self, parent, value):
        """remove value from tree rooted at parent"""
        if parent is None:
            return None

        if value == parent.value:
            return parent.delete()
        elif value < parent.value:
            parent.left = self.removeFromParent(parent.left, value)
        else:
            parent.right = self.removeFromParent(parent.right, value)

        return parent

如果我们专注于BinaryNode类下的delete方法，我需要一些帮助来了解指针，我之前已经编写了自己的二进制搜索树，但我不明白， self.left是指针吗？ self.left.right （参见grandchild ）是指从“开始”开始的指针，即将成为根，指向孩子，然后再指向（孙子）右边。 对于我来说， delete方法不需要使用要删除其值的参数也感到有点奇怪，我看不到其他任何使用该方法的地方...

Answer 1

左和右属性的对象。 实际上，它们被实现为对象引用，也就是指针。

self.left.right是self的左右孙（您的临时“根”）。 **自己*最多可以有四个孙女； 这是第二个（从左到右计数），左孩子的右孩子。

delete确实有一个参数： self 。 这样就知道要删除哪个节点。 该方法未在其他地方使用，因为其他任何方法都不需要删除节点。 您正在开发一个供外部使用的类，而不是一个自给自足的应用程序。

这足以很好地回答您当前的困惑吗？ 尝试用铅笔画出那棵树，并逐步尝试这些方法。 在逐步浏览代码时，请擦除并重新绘制指针。 也许更好，使用两种颜色，这样您就可以使用“ before”和“ after”指针，并在进行操作时对更改进行编号。

---

我不会说self充当哨兵节点； “前哨”概念更多的是在特定点停止迭代。

至于指针/对象二分法，我怀疑您遇到麻烦的原因之一是Python不允许您经常将两者分开。 每个变量值都是对变量对象的引用。

具体来说，self.right.left最终是对孙子的引用 。 但是，Python运行时系统使用它来直接访问孙对象。 换句话说， 您无法真正分辨出差异。 不管怎样想一想； 当它适合你的目的改变（如抓住了左外场，就好像它是一个对象，然后重新离开 ，就好像它是一个指针）。 Python使这成为一种量子态：波和粒子。

免责声明：您最终会打到来传递参数与熟悉的星号指针抢来的东西，如* my_list的能力。 在那种情况下，您确实有明显的不同...但是Python会将wave函数折叠回ASAP。 暂时不必担心，只需知道它会在以后出现，这样您就不会对到目前为止学到的东西失去信心。