数据结构 | 平衡二叉搜索树 | 问题 11

简介

二叉搜索树（BST）是一种常见的数据结构，它具有以下特点：对于任意节点，它的左子树中所有节点都小于它，右子树中所有节点都大于它。但是一般情况下，由于插入或者删除操作的执行，BST可能会退化成一个链表，这样就会影响搜索的效率。为了解决这一问题，我们可以使用平衡二叉搜索树（AVL树），保证插入、删除等操作的时间复杂度为O(logN)。

问题描述

给定一棵AVL树，求从树根到最小值节点的路径长度。

思路分析

由于AVL树是一种自平衡的二叉搜索树，因此它的高度比较小，我们可以采用递归的方式来遍历树，并计算路径长度。对于每个节点，我们需要比较它的左右子树的高度（注意需要特判空节点），并选择较小的一边继续递归。当递归到叶子节点时，更新路径长度，并返回。

代码实现

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
        self.height = 1
        
class AVLTree:
    def __init__(self):
        self.root = None
    
    def insert(self, val):
        def _insert(node, val):
            if not node:
                return TreeNode(val)
            if val < node.val:
                node.left = _insert(node.left, val)
            else:
                node.right = _insert(node.right, val)
            node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
            balance = self.get_balance(node)
            if balance > 1:
                if val < node.left.val:
                    return self.right_rotate(node)
                else:
                    node.left = self.left_rotate(node.left)
                    return self.right_rotate(node)
            if balance < -1:
                if val > node.right.val:
                    return self.left_rotate(node)
                else:
                    node.right = self.right_rotate(node.right)
                    return self.left_rotate(node)
            return node
        self.root = _insert(self.root, val)

    def get_height(self, node):
        return node.height if node else 0

    def get_balance(self, node):
        return self.get_height(node.left) - self.get_height(node.right)

    def left_rotate(self, node):
        right = node.right
        t = right.left
        right.left = node
        node.right = t
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        right.height = max(self.get_height(right.left), self.get_height(right.right)) + 1
        return right

    def right_rotate(self, node):
        left = node.left
        t = left.right
        left.right = node
        node.left = t
        node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
        left.height = max(self.get_height(left.left), self.get_height(left.right)) + 1
        return left

    def find_min(self):
        node = self.root
        while node.left:
            node = node.left
        return node

    def get_path_length(self, node, val):
        if not node:
            return 0
        elif node.val == val:
            return node.height - 1
        elif val < node.val:
            return self.get_path_length(node.left, val) + 1
        else:
            return self.get_path_length(node.right, val) + 1

测试

tree = AVLTree()
tree.insert(8)
tree.insert(6)
tree.insert(10)
tree.insert(5)
tree.insert(7)
tree.insert(9)
tree.insert(11)
node = tree.find_min()
print(tree.get_path_length(tree.root, node.val)) # 2

结论

这个问题可以通过递归的方法直接在AVL树上解决。由于AVL树自平衡的特性，我们能够保证搜索效率，并且算法时间复杂度为O(logN)。