给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 二叉搜索树:
              5
            /   \
           2     13

输出: 转换为累加树:
             18
            /   \
          20     13

第一种思路：

先得到中序遍历，然后得到整个树的结点值的和，

接着再遍历一次树，对每个节点加上 整个树的和 - 它自身和左子树之和。

这种方法比较慢。

class Solution(object):
    def convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        #每个节点应该加上整个树的和 减去 它自身和左子树之和
        if root is None:
            return None
        
        def inOrder(node):
            if not node:
                return []
            return inOrder(node.left) + [node.val] + inOrder(node.right)
            
        inorder = inOrder(root)
        
        dp = [0 for _ in range(len(inorder))]
        dp[0] = inorder[0]
        
        treesum = sum(inorder)
        for i in range(1, len(dp)):
            dp[i] = inorder[i] + dp[i - 1]
            
        def change(node):
            if not node:
                return 
            
            pos = inorder.index(node.val)
            node.val += treesum - dp[pos]
            change(node.left)
            change(node.right)
         
        change(root)
        return root
            

第二种思路：

直接按照右中左的顺序中序遍历整棵树，

用一个变量s记录下需要加的值。

# 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 convertBST(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        #右中左的遍历顺序
        if not root:
            return root
        self.s = 0
        
        def convert(node):
            if not node:
                return 
            
            convert(node.right)
            node.val += self.s
            self.s = node.val
            convert(node.left)
            
        convert(root)
        return root