429-二叉树（108. 将有序数组转换为二叉搜索树、538. 把二叉搜索树转换为累加树、 106.从中序与后序遍历序列构造二叉树、235. 二叉搜索树的最近公共祖先）

108. 将有序数组转换为二叉搜索树

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int left, int right)
    {
        if (left > right)    return nullptr;
        int mid = left + ((right - left) / 2);
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

538. 把二叉搜索树转换为累加树

class Solution {
private:
    int pre;

    void traversal(TreeNode* cur)
    {
        if (cur == nullptr)  return;
        traversal(cur->right);
        cur->val += pre;
        pre = cur->val;
        traversal(cur->right);
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }
};

106.从中序与后序遍历序列构造二叉树

class Solution {

public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0)    return nullptr;


        //后序遍历数组最后一个元素，就当当前的中间节点
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        //叶子节点
        if (postorder.size() == 1)   return root;

        // 找到中序遍历的切割点
        int del;
        for (del = 0; del < inorder.size(); del++)
        {
            if (inorder[del] == rootValue)   break;
        }

        // 切割中序数组
       // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + del);
        vector<int> rightInorder(inorder.begin() + del + 1, inorder.end());

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        //切割后续数组
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
    {
        if (inorder.size() == 0 || postorder.size() == 0)    return nullptr;
        return traversal(inorder, postorder);
    }
};

235. 二叉搜索树的最近公共祖先

class Solution {
public:
    TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
        if (cur == nullptr)  return cur;

        if (cur->val > p->val && cur->val > q->val)
        {
            TreeNode* left = traversal(cur->left, p, q);
            if (left != nullptr)
            {
                return left;
            }
        }

        if (cur->val < p->val && cur->val < q->val)
        {
            TreeNode* right = traversal(cur->right, p, q);
            if (right != nullptr)
            {
                return right;
            }
        }
        return cur;
    }

public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root, p, q);
    }
};