10 - 二叉树（一）

1. 验证二叉搜索树

这道题目比较容易陷入两个陷阱：

• 不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。
• 样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的。

class Solution {
public:
    TreeNode* pre =nullptr;
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;
        bool left = isValidBST(root->left);
        if(!left || (pre != nullptr && pre->val >= root->val)) return false;
        pre = root;
        return isValidBST(root->right);
    }
};

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

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。

只要给我们一个有序数组，如果强调平衡，都可以以线性结构来构造二叉搜索树。

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

3. 有序链表转为二叉搜索树

给定一个单链表的头节点 head ，其中的元素 按升序排序 ，将其转换为高度平衡的二叉搜索树。

• 方法一：转为有序数组来做

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        vector<int> vec;
        while(head != nullptr){
            vec.push_back(head->val);
            head = head->next;
        }
        return sortedListToBST(vec, 0 , vec.size() - 1);
    }
private:
    TreeNode* sortedListToBST(vector<int>& vec, int l, int r){
        if(l > r) return nullptr;
        int m = (l + r) / 2;
        TreeNode* root = new TreeNode(vec[m]);
        root->left = sortedListToBST(vec, l, m - 1);
        root->right = sortedListToBST(vec, m + 1, r);
        return root;
    }
};

• 方法二：用快慢指针找中间节点

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head){
        return divide(head, nullptr);
    }
private:
    TreeNode* divide(ListNode* left, ListNode* right){
        if(left == right) return nullptr;
        ListNode* mid = getMid(left, right);
        TreeNode* root = new TreeNode(mid->val);
        root->left = divide(left, mid);
        root->right = divide(mid->next, right);
        return root;
    }
    ListNode* getMid(ListNode* left, ListNode* right){
        ListNode* slow = left;
        ListNode* fast = left;
        while(fast != right && fast->next != right){
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
};

4. 将二叉搜索树变平衡

给你一棵二叉搜索树，请你返回一棵平衡后的二叉搜索树，新生成的树应该与原来的树有着相同的节点值。如果有多种构造方法，请你返回任意一种。

中序遍历把二叉树转变为有序数组，然后在根据有序数组构造平衡二叉搜索树。

class Solution {
public:
    TreeNode* balanceBST(TreeNode* root) {
        traversal(root);
        return getTree(0, vec.size() - 1);
    }
private:
    vector<int> vec;
    void traversal(TreeNode* root){
        if(root == nullptr) return;
        traversal(root->left);
        vec.push_back(root->val);
        traversal(root->right);
    }
    TreeNode* getTree(int l , int r){
        if(l > r) return nullptr;
        int m = (l + r) / 2;
        TreeNode* root = new TreeNode(vec[m]);
        root->left = getTree(l, m - 1);
        root->right = getTree(m + 1, r);
        return root;
    }
};