leetcode_二叉树 530. 二叉搜索树的最小绝对差

530. 二叉搜索树的最小绝对差

• 给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

• 差值是一个正数，其数值等于两值之差的绝对值。

• 关键点: 由于二叉搜索树的性质，中序遍历后得到的序列是已排序的，因此可以直接计算相邻节点的最小差异。

1. 深度优先遍历DFS (递归调用栈)

# 递归调用栈
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if not root:
            return
        res = []
        # 中序遍历
        def inorder(node):
            if not node:
                return
            inorder(node.left)
            res.append(node.val)
            inorder(node.right)

        inorder(root)
		# 检查最小绝对差
        res2 = []
        for i in range(len(res)):
                a = res[i+1] - res[i]
                res2.append(a)
        return min(res2)

#        min_n = float("inf")
#        for i in range(1, len(res)):
#            min_n = min(min_n, res[i] - res[i-1])     

#        return min_n

• 时间复杂度是 O(n)
• 空间复杂度是 O(h), h是树的高度

优化内存

# 优化内存
# 在中序遍历的过程中，记录前一个节点的值，并直接计算当前节点与前一个节点的差值。这样不需要额外存储整个中序遍历的结果。
    def getMinimumDifference(self, root):
        
        self.min_diff = float("inf")
        self.prev = None  # 记录前一个节点的值

        def inorder(node):
            if not node:
                return
            inorder(node.left)  # 遍历左子树
            if self.prev is not None:
                self.min_diff = min(self.min_diff, node.val - self.prev)
            self.prev = node.val  # 更新前一个节点的值
            inorder(node.right)  # 遍历右子树

        inorder(root)
        return self.min_diff

• 时间复杂度: O(n)
• 空间复杂度: 最坏情况下是 O(n)(树是线性结构时), 最好的情况下是 O(log n)（平衡二叉树）

2. 广度优先遍历BFS

# BFS
from collections import deque

class Solution:
    def getMinimumDifference(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: int
        """
        if not root:
            return 0
        
        # BFS using a queue
        queue = deque([root])
        res = []
        
        while queue:
            node = queue.popleft()
            res.append(node.val)
            
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        # 通过BFS收集的所有节点，进行排序
        res.sort()
        
        # 计算最小绝对差
        min_diff = float('inf')
        for i in range(1, len(res)):
            min_diff = min(min_diff, res[i] - res[i-1])
        
        return min_diff

• 时间复杂度：O(nlogn)，主要由排序操作引起
• 空间复杂度：O(n), n是节点个数