目录
力扣 98. 验证二叉搜索树 面试题 04.05. 合法二叉搜索树
一，二叉搜索树（二叉查找树，二叉排序树，BST）
二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
二，二叉搜索树的性质
1，二叉搜索树的中序遍历结果，一定是一个升序序列。
2，二叉搜索树的中序遍历结果中，任意相邻的两个节点，至少有一个节点的孩子数不超过1，更严格来讲，要么左边节点没有右孩子，要么右边节点没有左孩子。
三，插入节点
根据二叉搜索树的性质，中序遍历结果中任意相邻的两个节点，要么左边节点没有右孩子，要么右边节点没有左孩子，只要在这个空位上插入新节点即可。
换句话说，有这么一种算法，可以保证插入新节点后，它一定会是一个叶子节点，直接去掉这个叶子节点得到的树就是原树。
想通这一点后，递归的代码就变得非常简单。
代码：
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
};
void InsertNode(TreeNode* &root, TreeNode* node)
{
if(!root)root=node;
else if(root->val>node->val)InsertNode(root->left,node);
else InsertNode(root->right,node);
}
void InsertNode(TreeNode* &root, int val)
{
TreeNode* p= new TreeNode();
p->val=val;
InsertNode(root,p);
}我们用下文力扣 98. 验证二叉搜索树里面的代码，校验插入结果是否为BST，再用中序遍历结果辅助校验，确认节点都插入成功。
代码：
bool isValidBST(TreeNode* root, long long low, long long high){
if (!root)return true;
if (root->val <= low || root->val >= high)return false;
return isValidBST(root->left, low, root->val) && isValidBST(root->right, root->val, high);
}
bool isValidBST(TreeNode* root) {
return isValidBST(root, -1000, 1000);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int>v1;
if (root == NULL)return v1;
v1 = inorderTraversal(root->left);
v1.insert(v1.end(), root->val);
vector<int>v2 = inorderTraversal(root->right);
v1.insert(v1.end(), v2.begin(), v2.end());
return v1;
}
//输出一维vector
template<typename T>
void fcout(vector<T>&v)
{
for(int i=0;i<v.size();i++)cout<<v[i]<<" ";
cout<<endl;
}
int main()
{
TreeNode* root=NULL;
InsertNode(root,2);
InsertNode(root,5);
InsertNode(root,1);
InsertNode(root,4);
InsertNode(root,8);
InsertNode(root,3);
InsertNode(root,6);
cout<<int(isValidBST(root))<<endl;
vector<int>ret=inorderTraversal(root);
fcout(ret);
return 0;
}运行结果：
1
1 2 3 4 5 6 8
四，删除节点
1，拷贝
删除节点的时候会涉及到节点的拷贝，而拷贝有2种做法，一种是值拷贝，一种是把节点之间的互链重链。
为了思路清晰，我这里考虑的是两种方案都算拷贝。
对于要求不能用值拷贝的方法，我下面的思路还不能完全适用。
2，删除根节点
因为可以接受值拷贝，所以删除一个节点A，只需要考虑对于以A为根的树，删掉A并换上新的根节点即可。
所以我后面的测试也是不停的删除根节点，看看结果是否正常。
3，删除根节点的思路
按照情况分类，根据待删节点有没有左孩子，有没有右孩子，可以分成四种情况。
其中，左孩子和右孩子都有的情况下，找出右子树中的最小节点，它就是中序遍历序列中待删节点的后继节点，用这个后继节点替换待删节点即可。
根据后继节点是不是待删节点的孩子分两种情况处理。
代码：
TreeNode* GetMin(TreeNode* root)
{
if (!root)return root;
if (root->left)return GetMin(root->left);
return root;
}
TreeNode* GetParent(TreeNode* root, TreeNode* node)
{
if (!root || root == node || root->left == node || root->right == node)return root;
if (root->val > node->val)return GetParent(root->left, node);
return GetParent(root->right, node);
}
void DeleteNode(TreeNode*& node)
{
if (node->left == NULL) {
node = node->right;
return;
}
if (node->right == NULL) {
node = node->left;
return;
}
TreeNode* thenext = GetMin(node->right);
if (thenext == node->right) {
thenext->left = node->left, node = thenext;
return;
}
node->val = thenext->val;
TreeNode* p = GetParent(node, thenext);
p->left = thenext->right;
}这个代码，稍微改一下就可以适用于不能用值拷贝的场景。
测试代码：
void DeleteAndJudge(TreeNode* &root)
{
DeleteNode(root);
cout << endl << int(isValidBST(root)) << endl;
vector<int>ret = inorderTraversal(root);
fcout(ret);
}
int main()
{
TreeNode* root = NULL;
InsertNode(root, 2);
InsertNode(root, 5);
InsertNode(root, 1);
InsertNode(root, 4);
InsertNode(root, 8);
InsertNode(root, 3);
InsertNode(root, 6);
cout << int(isValidBST(root)) << endl;
vector<int>ret = inorderTraversal(root);
fcout(ret);
DeleteAndJudge(root);
DeleteAndJudge(root);
DeleteAndJudge(root);
DeleteAndJudge(root);
DeleteAndJudge(root);
DeleteAndJudge(root);
return 0;
}运行结果：
1
1 2 3 4 5 6 8
1
1 3 4 5 6 8
1
1 4 5 6 8
1
1 5 6 8
1
1 6 8
1
1 8
1
1
五，OJ实战
力扣 98. 验证二叉搜索树 面试题 04.05. 合法二叉搜索树
题目：
给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:
输入:
2
/ \
1 3
输出: true
示例 2:
输入:
5
/ \
1 4
/ \
3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。
代码：
class Solution {
public:
bool isValidBST(TreeNode* root, long long low, long long high){
if (!root)return true;
if (root->val <= low || root->val >= high)return false;
return isValidBST(root->left, low, root->val) && isValidBST(root->right, root->val, high);
}
bool isValidBST(TreeNode* root) {
return isValidBST(root, -3312345678, 3312345678);
}
};力扣 96. 不同的二叉搜索树
题目：
给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？
示例:
输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
思路：
递推式f(n)=f(n-1)+f(1)f(n-2)+...+f(n-2)f(1)+f(n-1)
代码：
class Solution {
public:
int numTrees(int n) {
if (n <= 0)return 1;
static map<int, int>ans;
if (ans[n])return ans[n];
int res = 0;
for (int i = 0; i < n; i++)res += numTrees(i)*numTrees(n - 1 - i);
return ans[n] = res;
}
};力扣 95. 不同的二叉搜索树 II
题目：
给定一个整数 n，生成所有由 1 ... n 为节点所组成的二叉搜索树。
示例:
输入: 3
输出:
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]
解释:
以上的输出对应以下 5 种不同结构的二叉搜索树：
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
代码：
class Solution {
public:
vector<TreeNode*> generateTrees(int low,int high) {
vector<TreeNode*>ans;
if (low > high)
{
ans.insert(ans.end(), NULL);
return ans;
}
if (low == high)
{
TreeNode *p = new TreeNode(low);
ans.insert(ans.end(), p);
return ans;
}
for (int i = low; i <= high; i++)
{
vector<TreeNode*>v1 = generateTrees(low, i - 1);
vector<TreeNode*>v2 = generateTrees(i + 1, high);
for (int k = 0; k < v1.size(); k++)
{
for (int j = 0; j < v2.size(); j++)
{
TreeNode *p = new TreeNode(i);
p->left = v1[k], p->right = v2[j];
ans.insert(ans.end(), p);
}
}
}
return ans;
}
vector<TreeNode*> generateTrees(int n) {
vector<TreeNode*>ans;
if (n <= 0)return ans;
return generateTrees(1, n);
}
};