Question

if not node:
    return node

这段代码是什么意思？

if not node.leftchild:
    print('removing the node with single rightchild')
    tempnode = node.rightchild
    del node
    return tempnode

在有一个孩子的情况下删除二进制搜索树中的项目时，如果删除一个节点，则需要将一个孩子连接到另一个节点。但是，我不明白它是如何工作的，因为没有声明指向另一个节点。返回后，“ tempnode”如何工作？我的意思是返回后没有用，但是我看是否返回None或其他值而不是tempnode，删除不起作用

这里是完整程序。

class Node:

    def __init__(self,data):
        self.data = data
        self.leftchild = None
        self.rightchild = None


class BinarySearchTree:

    def __init__(self):
        self.root = None

    def insert(self, data):
        if not self.root:
            self.root = Node(data)

        else:
            self.insert_node(data,self.root)

    def insert_node(self,data, node):

        if data < node.data:
            if node.leftchild:
                self.insert_node(data, node.leftchild)
            else:
                node.leftchild = Node(data)
        else:
            if node.rightchild:
                self.insert_node(data, node.rightchild)
            else:
                node.rightchild = Node(data)

    def remove(self, data):
        if self.root:
            self.root = self.remove_node(data, self.root)

    def remove_node(self, data, node):
        if not node:
            return node

        if data < node.data:
            node.leftchild = self.remove_node(data, node.leftchild)

        elif data > node.data:
            node.rightchild = self.remove_node(data, node.rightchild)

        else:

            if not node.leftchild and not node.rightchild:
                print('removing leaf node')
                del node
                return None

            if not node.leftchild:
                print('removing the node with single rightchild')
                tempnode = node.rightchild
                del node
                return tempnode

            elif not node.rightchild:
                print('removing the node with single lefttchild')
                tempnode = node.leftchild
                del node

                return tempnode

            print('removing the node with two childs')
            tempnode = self.get_predessor(node.leftchild)
            node.data = tempnode.data
            node.leftchild = self.remove_node(tempnode.data, node.leftchild)


        return node

    def get_predessor(self, node):

        if node.rightchild:
            return self.get_predessor(node.rightchild)

        return node




    def get_min_value(self):
        if self.root:
            return self.get_min(self.root)

    def get_min(self, node):
        if node.leftchild:
            return self.get_min(node.leftchild)

        return node.data

    def get_max_value(self):
        if self.root:
            return self.get_max(self.root)

    def get_max(self, node):
        if node.rightchild:
            return self.get_max(node.rightchild)
        return node.data

    def traverse(self):
        if self.root:
            self.traverse_in_order(self.root)

    def traverse_in_order(self, node):
        if node.leftchild:
            self.traverse_in_order(node.leftchild)

        print(node.data)

        if node.rightchild:
            self.traverse_in_order(node.rightchild)

Answer 1

remove_node是一个递归函数。设计该代码的目的是，只要给定数据等于节点（子节点）的数据，就将其删除并获取其子节点/子节点（孙子/孙子），并将其分配给父节点的子节点字段。 tempnode返回上一个递归。

在这里完成

if data < node.data:
    node.leftchild = self.remove_node(data, node.leftchild)

elif data > node.data:
    node.rightchild = self.remove_node(data, node.rightchild)

在这里

print('removing the node with two childs')
tempnode = self.get_predessor(node.leftchild)
node.data = tempnode.data
node.leftchild = self.remove_node(tempnode.data, node.leftchild)

在类内部返回函数结果，它是如何工作的？

1 个答案: