深度优先搜索&BST

• • 1. 验证二叉搜索树
  • 2. 将有序数组转为二叉搜索树
  • 3. 有序链表转为二叉搜索树
  • 4. 将二叉搜索树变平衡

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& 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& nums) {return sortedArrayToBST(nums,0,nums.size()-1);}
};

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

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

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

class Solution {
public:TreeNode* sortedListToBST(ListNode* head) {vector vec;while(head != nullptr){vec.push_back(head->val);head = head->next;}return sortedListToBST(vec, 0 , vec.size() - 1);}
private:TreeNode* sortedListToBST(vector& 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 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;}
};