654.最大二叉树
题目链接：最大二叉树
题目描述：给定一个不重复的整数数组
nums。 最大二叉树 可以用下面的算法从nums递归地构建:
- 创建一个根节点，其值为
nums中的最大值。- 递归地在最大值 左边 的 子数组前缀上 构建左子树。
- 递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回
nums构建的 最大二叉树 。
解题思想：
构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。
class Solution {
public:
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
if (nums.size() == 0)
return NULL;
if (nums.size() == 1)
return new TreeNode(nums[0]);
int index;
int max = 0;
for (int i = 0; i < nums.size(); i++) {
if (nums[i] > max) {
max = nums[i];
index = i;
}
}
TreeNode* root = new TreeNode(max);
vector<int> leftNums(nums.begin(), nums.begin() + index);
vector<int> rightNums(nums.begin() + index + 1, nums.end());
root->left = constructMaximumBinaryTree(leftNums);
root->right = constructMaximumBinaryTree(rightNums);
return root;
}
};
以上代码比较冗余，效率也不高，每次还要切割的时候每次都要定义新的vector（也就是数组），但逻辑比较清晰。上面代码优化思路，就是每次分隔不用定义新的数组，而是通过下标索引直接在原数组上操作。
class Solution {
public:
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
return traversal(nums, 0, nums.size());
}
private:
TreeNode* traversal(vector<int>& nums, int left, int right) {
if (left >= right)
return NULL;
TreeNode* root = new TreeNode(0);
if (right - left == 1) {
root->val = nums[left];
return root;
}
int index = left;
for (int i = left + 1; i < right; i++) {
if (nums[i] > nums[index])
index = i;
}
root->val = nums[index];
root->left = traversal(nums, left, index);
root->right = traversal(nums, index + 1, right);
return root;
}
};
617.合并二叉树
题目链接：合并二叉树
题目描述给你两棵二叉树：
root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
注意: 合并过程必须从两个树的根节点开始。
递归法：
class Solution {
public:
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
if (root1==NULL) return root2;
if (root2==NULL) return root1;
root1->val += root2->val;
root1->left = mergeTrees(root1->left,root2->left);
root1->right = mergeTrees(root1->right,root2->right);
return root1;
}
};
迭代法：
使用队列模拟层序遍历，如果两棵树左/右节点都不为空，将两颗树左/右节点加入队列，当root1的左/右节点为空，root2的左/右节点不为空，就赋值过去。
class Solution {
public:
TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
if (root1 == NULL)
return root2;
if (root2 == NULL)
return root1;
queue<TreeNode*> que;
que.push(root1);
que.push(root2);
while (!que.empty()) {
TreeNode* tree1 = que.front();
que.pop();
TreeNode* tree2 = que.front();
que.pop();
tree1->val += tree2->val;
if (tree1->left != NULL && tree2->left != NULL) {
que.push(tree1->left);
que.push(tree2->left);
}
if (tree1->right != NULL && tree2->right != NULL) {
que.push(tree1->right);
que.push(tree2->right);
}
if (tree1->left == NULL && tree2->left != NULL) {
tree1->left = tree2->left;
}
if (tree1->right == NULL && tree2->right != NULL) {
tree1->right = tree2->right;
}
}
return root1;
}
};
700.二叉搜索树中的搜索
题目链接：二叉搜索树中的搜索
题目描述：给定二叉搜索树（BST）的根节点
root和一个整数值val。你需要在 BST 中找到节点值等于
val的节点。 返回以该节点为根的子树。 如果节点不存在，则返回null。
解题思路：
二叉搜索树是一个有序树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
递归法：
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
if (root == NULL || root->val == val) return root;
TreeNode* result = NULL;
if (root->val > val) result = searchBST(root->left, val);
if (root->val < val) result = searchBST(root->right, val);
return result;
}
};
迭代法：
对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。
例如要搜索元素为3的节点，**我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。**中间节点如果大于3就向左走，如果小于3就向右走，如图：
!https://code-thinking-1253855093.file.myqcloud.com/pics/20200812190213280.png
class Solution {
public:
TreeNode* searchBST(TreeNode* root, int val) {
while (root != NULL) {
if (root->val < val)
root = root->right;
else if (root->val > val)
root = root->left;
else
return root;
}
return NULL;
}
};
98.验证二叉搜索树
题目链接：验证二叉搜索树
题目描述：给你一个二叉树的根节点
root，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：
节点的左只包含 小于 当前节点的数。
子树
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
解题思路：
这里主要用到了二叉搜索树的性质，即中序遍历是单调递增的。这里注意一个树每个节点的左节点都小于该节点，右节点都大于该节点并不能说明这个树是二叉搜索树。
例如： [10,5,15,null,null,6,20] 这个case：
节点10大于左节点5，小于右节点15，但右子树里出现了一个6 这就不符合了！
递归法：
最直接的一种递归法就是中序遍历一遍二叉树，将数组保存在数组中，再判断数组是否单调递增。
class Solution {
private:
vector<int> vec;
void traversal(TreeNode* root) {
if (root == NULL) return;
traversal(root->left);
vec.push_back(root->val); // 将二叉搜索树转换为有序数组
traversal(root->right);
}
public:
bool isValidBST(TreeNode* root) {
vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
traversal(root);
for (int i = 1; i < vec.size(); i++) {
// 注意要小于等于，搜索树里不能有相同元素
if (vec[i] <= vec[i - 1]) return false;
}
return true;
}
};
也可以不转化为数组，而在遍历的过程中使用双指针，比较当前遍历的节点和前一个节点的值。
class Solution {
public:
bool isValidBST(TreeNode* root) {
if (root == NULL)
return true;
bool left = isValidBST(root->left);
if (pre != NULL && pre->val >= root->val)
return false;
pre = root;
bool right = isValidBST(root->right);
return left && right;
}
private:
TreeNode* pre = NULL;
};
迭代法：
使用迭代法的中序遍历，比较的逻辑和递归法一样。
class Solution {
public:
bool isValidBST(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* cur = root;
TreeNode* pre = NULL;
while (cur != NULL || !st.empty()) {
if (cur != NULL) {
st.push(cur);
cur = cur->left;
} else {
cur = st.top();
st.pop();
if (pre != NULL && pre->val >= cur->val)
return false;
pre = cur;
cur = cur->right;
}
}
return true;
}
};
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
