[leetcode: Python]530. Minimum Absolute Difference in BST

Given a binary search tree with non-negative values, find the minimum absolute difference between values of any two nodes.

Example:

Input:

   1
    \
     3
    /
   2

Output:
1

Explanation:
The minimum absolute difference is 1, which is the difference between 2 and 1 (or between 2 and 3).

Note: There are at least two nodes in this BST.

方法一：132ms
递归

对于BST中的某节点N：

大于N的最小节点为其右孩子的“极左节点”

小于N的最大节点为其左孩子的“极右节点”

然后递归取最小值

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        left = root.left
        right = root.right
        Min = 0x7fffffff
        if left:
            while left.right:
                left = left.right
            Min = min(root.val - left.val, self.getMinimumDifference(root.left))
        if right:
            while right.left:
                right = right.left
            Min = min(Min, right.val - root.val, self.getMinimumDifference(root.right))
        return Min

方法二：105ms

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        values = []
        valuesInOrder = []
        minDifference = 1 << 32
        def valueRecord(root):
            if not root:
                return 
            values.append(root.val)
            valueRecord(root.left)
            valueRecord(root.right)
        valueRecord(root)
        valuesInOrder = sorted(values)
        for i in xrange(len(valuesInOrder)-1):
            if valuesInOrder[i+1] - valuesInOrder[i] < minDifference:
                minDifference = valuesInOrder[i+1] - valuesInOrder[i]
        return minDifference

方法三：89ms
中序遍历将BST中的节点按照递增顺序输出

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 

        temp=[]
        node = self.inorder(root,temp)
        temp2 = min([abs(node[i+1] - node[i]) for i in range(len(node)-1)])
        return temp2

    def inorder(self,root,temp):
        if root == None:
            return 
        self.inorder(root.left,temp)
        temp.append(root.val)
        self.inorder(root.right,temp)
        return temp

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getMinimumDifference(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.last = -0x80000000
        self.ans = 0x7FFFFFFF
        def inOrderTraverse(root):
            if not root: return
            inOrderTraverse(root.left)
            self.ans = min(self.ans, root.val - self.last)
            self.last = root.val
            inOrderTraverse(root.right)
        inOrderTraverse(root)
        return self.ans

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def getMinimumDifference(self, root):
        if not root:
            return 0
        res=[]
        def innerOrder(node):
            if node:
                innerOrder(node.left)
                res.append(node.val)
                innerOrder(node.right)
        innerOrder(root)

        minnum=min([res[i]-res[i-1] for i in range(1,len(res))])
        return minnum