6.二叉树.题目2
题目
9.找树左下角的值
题目链接
给定一个二叉树，在树的最后一行找到最左边的值。此时可以想到使用层序遍历会非常简单，也是十分自然的。但也可以使用递归来解决（后序再进行补充），但会麻烦一点。
广度优先-迭代法
int findBottomLeftValue(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
int result = 0;
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if (i == 0) result = node->val; // 记录最后一行第一个元素
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return result;
}
10.路径总和
题目链接
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。这题可以看作是7.二叉树的所有路径题目的扩展
递归法-前中后序都可以
- 确定递归函数的参数&返回类型：需要二叉树的根节点，需要一个计数器（用来计算二叉树的一条边之和是否等于目标和）；递归函数返回类型是bool。
- 终止条件：当遍历到叶子节点时候的判断
bool traversal(TreeNode* cur, int count){
if(!cur->left&&!cur->right && count==0) return true;
if(!cur->left&&!cur->right) return false;
if(cur->left){
count -=cur->left->val;
if(traversal(cur->left, count)) return true;
count +=cur->left->val;
}
if(cur->right){
count -=cur->right->val;
if(traversal(cur->right, count)) return true;
count +=cur->right->val;
}
return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
if(root==nullptr) return false;
return traversal(root, targetSum-root->val);
}
深度遍历-迭代法
此时栈里一个元素不仅要记录该节点的指针，还要记录从根节点到该节点的数值之和，因此需要用到std::pair<TreeNode*, int>的数据类型，加入到栈的遍历中。
bool haspathsum(TreeNode* root, int sum) {
if (root == null) return false;
// 此时栈里要放的是pair<节点指针，路径数值>
stack<pair<TreeNode*, int>> st;
st.push(pair<TreeNode*, int>(root, root->val));
while (!st.empty()) {
pair<TreeNode*, int> node = st.top();
st.pop();
if (!node.first->left && !node.first->right && sum == node.second) return true;
if (node.first->right) {
st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
}
if (node.first->left) {
st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
}
}
return false;
}
11.从中序与后序遍历序列构造二叉树
题目链接
根据一棵树的中序遍历与后序遍历构造二叉树，注意你可以假设树中没有重复的元素。
例如给出中序遍历 inorder = [9,3,15,20,7]；后序遍历 postorder = [9,15,7,20,3]；需要你返回：
根据总结里面提到的切割法：1.判断数组是否非空 2.若非空，取出后序数组最后一个数值作为新节点的值 3.用该值对中序数组进行切割（不包含切割点）4.根据切完的左子中序数组的大小对后序数组进行切割（不包含最后一个数值）5.得到新的子中序数组，后续数组 ，进入下一层递归。
TreeNode* traversal(std::vector<int> inorder, int in_begin, int in_end, std::vector<int> postorder, int post_begin, int post_end){
if(post_begin==post_end) return nullptr;
int rootvalue = postorder[post_end-1];
TreeNode* root = new TreeNode(rootvalue);
if(post_end-post_begin==1) return root;
// 获取中序数组切割点索引-根据后续数组的最后一个数值
int delimiterIndex;
for(delimiterIndex=in_begin; delimiterIndex<in_end; delimiterIndex++){
if(inorder[delimiterIndex]==rootvalue) break;
}
// 切割-以左闭右开的形式存储数值
// 切割中序数组的切割点是不保留的
int left_in_begin = in_begin;
int left_in_end = delimiterIndex;
int right_in_begin = delimiterIndex + 1;
int right_in_end = in_end;
// 根据切割完的左子后序数组的数量进行切割后序数组，不保留最后一个数值
int left_post_begin = post_begin;
int left_post_end = post_begin + left_in_end - left_in_begin;
int right_post_begin = post_begin + left_in_end - left_in_begin;
int right_post_end = post_end-1;
root->left = traversal(inorder, left_in_begin, left_in_end, postorder, left_post_begin, left_post_end);
root->right = traversal(inorder, right_in_begin, right_in_end, postorder, right_post_begin, right_post_end);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if(inorder.size()==0 || postorder.size()==0) return nullptr;
return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
}
从前序与中序遍历序列构造二叉树
题目链接
12.最大二叉树
题目链接
给定一个不含重复元素的整数数组，一个以此数组构建的最大二叉树定义如下：
- 二叉树的根是数组中的最大元素。
- 左子树是通过数组中最大值左边部分构造出的最大二叉树。
- 右子树是通过数组中最大值右边部分构造出的最大二叉树。
构造树一般采用前序遍历，因为先构造中间节点，再构造左，右子节点。 这题可以使用递归法来解决，类似寻找切割点，构建节点，切割数组得到左右子数组，进入下一层迭代。
TreeNode* travesal(std::vector<int>& nums, int left, int right){
if(left>=right) return nullptr;
int maxvalueindex = left;
for(int i = left+1; i<right; i++){
if(nums[i]>nums[maxvalueindex]) maxvalueindex = i;
}
TreeNode* root = new TreeNode(nums[maxvalueindex]);
root->left = travesal(nums, left, maxvalueindex);
root->right = travesal(nums, maxvalueindex+1, right);
return root;
}
TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
return travesal(nums, 0, nums.size());
}
13.合并二叉树
（题目链接）
给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
递归法-在了解回溯算法后比较容易理解
// 前序法
TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
// 修改了t1的数值和结构
t1->val += t2->val; // 中
t1->left = mergeTrees(t1->left, t2->left); // 左
t1->right = mergeTrees(t1->right, t2->right); // 右
return t1;
}
迭代法-常规使用stack堆存储要遍历的元素
14.二叉搜索树中的搜索
（题目链接）
给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
重新复习搜索二叉树
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉搜索树
递归法
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;
}
迭代法
对于二叉搜索树可就不一样了，因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法；对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的。
TreeNode* searchBST(TreeNode* root, int val) {
while (root != NULL) {
if (root->val > val) root = root->left;
else if (root->val < val) root = root->right;
else return root;
}
return NULL;
}
因为二叉搜索树的有序性，遍历的时候要比普通二叉树简单很多。
15.验证二叉搜索树
（题目链接）
给定一个二叉树，判断其是否是一个有效的二叉搜索树。即检查该二叉树是否满足二叉搜索树的定义。
中序遍历下，输出的二叉搜索树节点的数值是有序序列。验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。
递归
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;
}
把二叉树转变为数组来判断，是最直观的，但其实不用转变成数组，可以在递归遍历的过程中直接判断是否有序。有三个陷阱需要解决
迭代法-中序遍历
16.二叉搜索树的最小绝对差
（题目链接）
给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。
遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。
2290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
