找树左下角的值
题目:给定一个二叉树,在树的最后一行找到最左边的值。
思路:1.层序遍历 2.递归
递归
找最后一行,最左边,深度最大的叶子节点。
最左边,左优先,保证优先左边搜索,记录深度最大的叶子节点,此时就是树的最后一行最左边的值。无 中间节点的处理逻辑,可以使用前序遍历、也可以中后,左优先就可以。
递归三部曲:
1.确定递归函数的参数和返回值
参数必须有要遍历的树的根节点,还有就是一个int型的变量用来记录最长深度。这里就不需要返回值了,所以递归函数的返回值类型为void.
本题还需要类里的两个全局变量,maxLen用来记录最大深度,result记录最大深度最左节点的数值。
代码如下:
int maxDepth = INT_MIN; //全局变量,记录最大深度
int result;//全局变量 最大深度最左节点的数值
void traversal(TreeNode* root,int depth)
2.确定终止条件
当遇到叶子节点的时候,就需要统计一下最大的深度了,所以需要遇到叶子节点来更新最大深度。
if(root->left == NULL && root->right == NULL){
if(depth > maxDepth){
maxDepth = depth;//更新最大深度
result = root->val;//最大深度最左面的数值
}
return;
}
3.确定单层递归的逻辑
在找最大深度的时候,递归的过程中依然要使用回溯,代码如下:
if(root->left){
depth++;
traversal(root->left,depth);
depth--;
}
if(root->right){
depth++; //深度加一
traversal(root->right,depth);
depth--;
}
return;
class Solution{
public:
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* root,int depth){
if(root->left == NULL && root->right == NULL){
if(depth > maxDepth){
maxDepth = depth;
result = root->val;
}
return;
}
if(root->left){
depth++;
traversal(root->left,depth);
depth--;
}
if(root->right){
depth++;
traversal(root->right,depth);
depth--;
}
return;
}
int findBottomLeftValue(TreeNode* root){
traversal(root,0);
return result;
}
};
回溯的地方精简一下
class Solution{
public:
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* root,int depth){
if(root->left == NULL && root->right == NULL){
if(depth > maxDepth){
maxDepth = depth;
result = root->val;
}
return;
}
if(root->left){
traversal(root->left,depth + 1);
}
if(root->right){
traversal(root->right,depth + 1);
}
return;
}
int findBottomLeftValue(TreeNode* root){
traversal(root,0);
return result;
}
;
}
迭代法
层序遍历,进行迭代
class Solution{
public:
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;
}
};
递归求深度,递归中隐藏了回溯,层序遍历
路径总和
给定一个二叉树和一个目标和,判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和。
存在就返回true
思路:
遍历从根节点到叶子节点的路径看看总和是不是目标和。
递归
可以使用深度优先遍历的方式,因为中节点没有处理逻辑,所以前中后序遍历都可以。
1.确定递归函数的参数和返回类型
参数:需要二叉树的根节点,还需要一个计数器,这个计数器用来计算二叉树的一条边之和是否正好是目标和,计数器为int型。
返回值:
>>如果需要搜索整棵二叉树且不用处理递归函数返回值,递归函数就不要返回值。
>>如果需要搜索整棵二叉树且需要处理递归返回值,递归函数就需要返回值。
>>如果要搜索其中一条符合条件的路径,那么递归一定需要返回值,因为遇到符合条件的路径了就要及时返回。
这道题中,我们要找到其中一条符合条件的路径,所以递归函数需要返回值,及时返回,那么返回类型是什么呢?
遍历的路线,并不一定遍历整棵树,所以递归函数需要返回值,可以用bool类型表示。
所以代码如下:
bool traversal(treenode* cur,int count)//注意函数的返回类型
2.确定终止条件
首先计数器如何统计这一条路径的和呢?
不去累加然后判断是否等于目标和,那么代码比较麻烦,可以用递减,让计数器count初始值为目标和,然后每次减去遍历路径节点上的数值。
如果最后count == 0,同时到了叶子节点的话,说明找到了目标和。
如果遍历到了叶子节点,count不为0,就是没找到。
递归终止条件代码如下:
if(!cur->left && !cur->right && count == 0)return true;//遇到叶子节点,并且计为0
if(!cur->left && !cur->right)return false;//遇到叶子节点而没有找到合适的边,直接返回
3.确定单层递归的逻辑
因为终止条件是判断叶子节点,所以递归的过程中就不要让空节点进入递归了。
递归函数是有返回值的,如果递归函数返回true,说明找到了合适的路径,应该立刻返回。
代码如下:
if(cur->left){
//遇到叶子节点返回true,则直接返回true
if(traversal(cur->left,count - cur->left->val))return true;
}
if(cur -> right){
if(traversal(cur->right,count - cur->right->val))return true;
}
return false;
以上代码是包含着回溯的,没有回溯,如何后撤重新找另一条路径呢?
回溯隐藏在traversal ( cur -> left, count - cur -> left -> val)这里,因为把 count - cur -> left -> val直接作为参数传进去,函数结束,count的数值没有改变。
为了把回溯的过程体现出来,可以改为如下代码:
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;
//整体代码
class Solution{
private:
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;
}
public:
bool hasPathSum(TreeNode* root,int sum){
if(root == NULL)return false;
return traversal(root,sum - root ->val);
}
};
//精简后
class Solution{
public:
bool hasPathSum(TreNode* root,int sum){
if(!root)return false;
if(!root->left && !root->right && sum == root->val){
return true;
}
return hasPathSum(root->left,sum - root->val)||hasPathSum(root->right,sum - root->val);
}
};
迭代
如果使用栈模拟递归的话,那么如果做回溯呢?
此时栈里一个元素不仅要记录该节点指针,还要记录从头节点到该节点的路径数值总和。
C++中用pair结构来存放这个栈里的元素。
定义为: pair<TreeNode* ,int> pair<节点指针,路径数值>
这个为栈里的一个元素。
//使用栈模拟,前序遍历
class Solution{
public:
bool hasPathSum(TreeNode* root,int sum){
if(root == null)return false;
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))
}
}
return false;
}
};
构造二叉树
题目:根据一棵树的中序遍历与后序遍历构造二叉树。
假设树中没有重复的元素。
思路:以 后序数组的最后一个元素为分割点,先切中序数组,反过来再切后序数组。一层一层切下去,每次后序数组最后一个元素就是节点元素。
class Solution {
private:
TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
if (postorder.size() == 0) return NULL;
int rootValue = postorder[postorder.size() - 1];
TreeNode* root = new TreeNode(rootValue);
if (postorder.size() == 1) return root;
int delimiterIndex;
for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
if (inorder[delimiterIndex] == rootValue) break;
}
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );
postorder.resize(postorder.size() - 1);
vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
// 以下为日志
cout << "----------" << endl;
cout << "leftInorder :";
for (int i : leftInorder) {
cout << i << " ";
}
cout << endl;
cout << "rightInorder :";
for (int i : rightInorder) {
cout << i << " ";
}
cout << endl;
cout << "leftPostorder :";
for (int i : leftPostorder) {
cout << i << " ";
}
cout << endl;
cout << "rightPostorder :";
for (int i : rightPostorder) {
cout << i << " ";
}
cout << endl;
root->left = traversal(leftInorder, leftPostorder);
root->right = traversal(rightInorder, rightPostorder);
return root;
}
public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (inorder.size() == 0 || postorder.size() == 0) return NULL;
return traversal(inorder, postorder);
}
};