二叉搜索树删除中基本情况的目的

Question

I am taking a course on algorithms and data structures in Python 3 and my instructor recently introduced us to the binary search tree. However, I am having trouble understanding the deletion algorithm. Below is the implementation we were taught, however when I initially wrote my own rendition, I did not include a "base case" and it still worked:

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

def remove_node(self, data, node):
     if node is None:
        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.rightChild and not node.leftChild:
            print('removing leaf node')
            del node
            return None
        if not node.leftChild:
            print('removing node with single right child')
            tempNode = node.rightChild
            del node
            return tempNode
        elif not node.rightChild:
            print('removing node with single left child')
            tempNode = node.leftChild
            del node
            return tempNode
        print('removing node with two children')
        tempNode = self.get_predecessor(node.leftChild)
        node.data = tempNode.data
        node.leftChild = self.remove_node(tempNode.data, node.leftChild)
    return node

Now, all of this makes sense to me except the statement below:

if node is None:
    return node

When we previously learned about base cases, we were taught that they were essentially the exit points for our algorithms. However, I do not understand how this is the case in the given code. For one, I do not see how a node could ever be empty and even if it was, why would we return an empty node? As far as I can see, this check serves no purpose in the overall recursion because we do not seem to "recur towards it" as we would in any other recursive function. I would greatly appreciate an explanation!

Answer 1

Base case(s), in general, serve one or more purposes, these include;

1. preventing the function from recursing infinitely
2. preventing the function from throwing errors on corner cases
3. compute/return a value/result to callers higher up in the recursion tree

With tree deletion, the first point isn't really a concern (because the recursion tree will only have a finite number of nodes - same as the tree you recurse over). You will be concerned with points 2 and 3 here.

In your function, you do have a base case - in fact, you have two (thanks to @user2357112) -

1. The value-not-found portion, specified by

    if node is None: return node 

   and,

2. The value-found portion, specified by your code inside the else statement, which performs the actual deletion.

To keep the behaviour consistent with the recursive cases, the value-not-found base case returns None . As you see, the first base case is consistent performs the second function of a generic base case outlined above, while the second base case performs the third.