4.17
236. 二叉树的最近公共祖先 - 力扣（LeetCode）
答疑
问：
lowestCommonAncestor函数的返回值是什么意思？答：返回值的准确含义是「最近公共祖先的候选项」。对于最外层的递归调用者来说，返回值是最近公共祖先的意思。但是，在递归过程中，返回值不一定是最近公共祖先，可能是空节点（表示子树内没找到任何有用信息）、节点 p 或者节点 q（可能成为最近公共祖先，或者用来辅助判断某个节点是否为最近公共祖先）。
问：为什么发现当前节点是 p 或者 q 就不再往下递归了？万一下面有 q 或者 p 呢？
答：如果下面有 q 或者 p，那么当前节点就是最近公共祖先，直接返回当前节点。
如果下面没有 q 和 p，那既然都没有要找的节点了，也不需要递归，直接返回当前节点。
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if (root == nullptr || root == p || root == q) {
return root;//第一层递归：如果p、q是根节点，那么一定是最近公共祖先
//后面的递归，返回的是候选项，比如left = root = p,right = root = q，那么会回到第一层递归if(p && q) return root
}
TreeNode* left = lowestCommonAncestor(root->left, p, q);
TreeNode* right = lowestCommonAncestor(root->right, p, q);
if (left && right) { // 左右都找到
return root; // 当前节点是最近公共祖先
}
return left ? left : right;
}
};
235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）
二叉搜索树包含于二叉树，所以上一题的代码，这题也能过。
class Solution {
public:
TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q) {
int x = root->val;
if (p->val < x && q->val < x) { // p 和 q 都在左子树
return lowestCommonAncestor(root->left, p, q);
}
if (p->val > x && q->val > x) { // p 和 q 都在右子树
return lowestCommonAncestor(root->right, p, q);
}
return root; // 其它
}
};
670. 最大交换 - 力扣（LeetCode）
举例说明，假设 num=9952767。为了得到最大值，我们来看看怎么贪心：
- 从左往右考察 num 的每个数字，如果一个数字右边没有比它大的，那么肯定无需交换它。比如这里的 9，无论它和谁交换都不能让 num 更大。
- 反之，如果一个数字右边有比它大的数，那么肯定要交换它，比如这里的 5，右边有比它大的 7 和 6，为了让 num 尽量大，和 7 交换最优。
- 但是，如果有多个 7 呢？我们应该和哪个 7 交换呢？
- 如果和第一个 7 交换，我们得到的是 9972567。
- 如果和第二个 7 交换，我们得到的是 9972765。
- 和最后一个 7 交换是最优的。
设 num 的十进制字符串为 s。算法如下：
- 倒序遍历 s，同时维护最大数的下标
maxIdx。它只在遇到更大的数字才更新，遇到相同数字不会更新，从而满足上面讨论的「最后一个」。- 如果发现
s[i]<s[maxIdx]，满足交换要求，我们先把这两个下标保存在变量 p 和 q 中。注：p 在遍历前的初始值为 −1。- 继续向左遍历，如果又遇到
s[i]<s[maxIdx]，就更新p=i, q=maxIdx，因为 s[i] 越靠左越好，我们要交换的是从左到右第一个右边有比它大的数字。- 遍历结束，如果无需交换，即 p=−1，那么直接返回 num。否则交换 s[p] 和 s[q]，然后把 s 转换成数字返回。
class Solution {
public:
int maximumSwap(int num) {
string s = to_string(num);
int n = s.length();
int max_idx = n - 1;
int p = -1 , q;
for(int i = n - 2 ; i >= 0 ; i --){
if(s[i] > s[max_idx]) max_idx = i;//倒序遍历以找到最后一个最大的数
else if(s[i] < s[max_idx]){// s[i] 右边有比它大的
p = i;
q = max_idx;// 更新 p 和 q
}
}
if(p == -1) return num;// 这意味着 s 是降序的
swap(s[p] , s[q]);
return stoi(s);
}
};
26. 删除有序数组中的重复项 - 力扣（LeetCode）
为方便描述，把 nums 记作 a。
示例 2 的 a=[0,0,1,1,1,2,2,3,3,4]。
首先 a0 = 0 肯定要保留，我们从 a1 开始讨论：
- 如果 a1 = a0，那么 a1 是重复项，不保留。
- 如果 a1 != a0，那么 a1 不是重复项，保留。
具体算法如下：
- 初始化 k=1，表示保留的元素要填入的下标。
- 从 i=1 开始遍历 nums。
- 如果 nums[i] = nums[i−1]，那么 nums[i] 是重复项，不保留。
- 如果 nums[i]\=nums[i−1]，那么 nums[i] 不是重复项，保留，填入 nums[k] 中，然后把 k 加一。
- 遍历结束后，k 就是 nums 中的唯一元素的数量，返回 k。
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int n = 1;
for (int i = 1; i < nums.size(); i++) {
if(nums[i] == nums[i - 1]) continue;
nums[n ++] = nums[i];
}
nums.resize(n);
return n;
}
};
附：库函数写法
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
return unique(nums.begin(), nums.end()) - nums.begin();
}
93. 复原 IP 地址 - 力扣（LeetCode）
判断子串是否合法
根据题目提示：
1 <= s.length <= 20s仅由数字组成主要考虑到如下三点：
- 段位以0为开头的数字不合法
- 段位里有非正整数字符不合法（这条去掉也能过，样例已有限制）
- 段位如果大于255了不合法
递归参数：
- startIndex ：防止重复分割，记录下一层递归的起始位置
- pointNum ： 记录添加‘.’的数量，为3时收割答案
递归终止条件：
pointNum == 3 && 最后一段子字符串合法单层搜索逻辑：
for (int i = startIndex; i < s.size(); i++)循环中[startIndex, i]这个区间就是截取的子串，需要判断这个子串是否合法。
如果合法就在字符串后面加上符号
.表示已经分割。如果不合法就结束本层循环，如图中剪掉的分支：
递归回溯：
下一层递归startIndex = i + 2（加了个‘.’），pointNum = pointNum + 1。
回溯的时候erase掉s中加入的‘.’即可。
代码如下：
class Solution { // 判断字符串s在左闭右闭区间[start, end]所组成的数字是否合法 bool isValid(const string& s , int start , int end){ if(start > end) return false; // 0开头的数字不合法 if(s[start] == '0' && start != end) return false; int num = 0; for (int i = start; i <= end; i++) { // 遇到非数字字符不合法，本题可以去掉 if(s[i] > '9' || s[i] < '0') return false; num = num * 10 + (s[i] - '0'); // 如果大于255了不合法 if(num > 255) return false; } return true; } public: vector<string> restoreIpAddresses(string s) { vector<string> res; //边界条件剪枝 if(s.size() < 4 || s.size() > 12) return res; // startIndex: 搜索的起始位置，pointNum:添加逗点的数量 auto dfs = [&](this auto&& dfs , int startIndex , int pointNum){ if(pointNum == 3){ // 逗点数量为3时，分隔结束 // 判断第四段子字符串是否合法，如果合法就放进result if(isValid(s , startIndex , s.size() - 1)) res.push_back(s); return; } for (int i = startIndex; i < s.size(); i++) {// 判断 [startIndex,i] 这个区间的子串是否合法 if(isValid(s , startIndex , i)){ s.insert(s.begin() + i + 1 , '.'); dfs(i + 2 , pointNum + 1); s.erase(s.begin() + i + 1); } else break;// 如果不合法，后续的都不合格，直接结束本层循环 } }; dfs(0 , 0); return res; } };
- 时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
- 空间复杂度: O(n)
相关题：131. 分割回文串 - 力扣（LeetCode）
思路
本题这涉及到两个关键问题：
- 切割问题，有不同的切割方式
- 判断回文
我们来分析一下切割，其实切割问题类似组合问题。
例如对于字符串abcdef：
- 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个.....。
- 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段.....。
所以切割问题，也可以抽象为一棵树形结构，如图：
递归用来纵向遍历，for循环用来横向遍历，切割线（就是图中的红线）切割到字符串的结尾位置，说明找到了一个切割方法。
此时可以发现，切割问题的回溯搜索的过程和组合问题的回溯搜索的过程是差不多的。
回溯三部曲
- 递归函数参数
全局变量数组path存放切割后回文的子串，二维数组result存放结果集。 （这两个参数可以放到函数参数里）本题递归函数参数还需要
startIndex，因为切割过的地方，不能重复切割，和组合问题也是保持一致的。如果是一个集合来求组合的话，就需要startIndex，例如：77.组合 (opens new window)，216.组合总和III (opens new window)。
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：17.电话号码的字母组合(opens new window)
注意以上只是说求组合的情况，如果是排列问题，又是另一套分析的套路
- 递归函数终止条件
从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。
- 单层搜索的逻辑
来看看在递归循环中如何截取子串呢？
在
for (int i = startIndex; i < s.size(); i++)循环中，我们定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。首先判断这个子串是不是回文，如果是回文，就加入在
vector<string> path中，path用来记录切割过的回文子串。注意切割过的位置，不能重复切割，所以，backtracking(s, i + 1); 传入下一层的起始位置为i + 1。
判断回文子串
最后我们看一下回文子串要如何判断了，判断一个字符串是否是回文。
可以使用双指针法，一个指针从前向后，一个指针从后向前，如果前后指针所指向的元素是相等的，就是回文字符串了。
那么判断回文的C++代码如下：
bool isPalindrome(const string& s, int start, int end) { for (int i = start, j = end; i < j; i++, j--) { if (s[i] != s[j]) { return false; } } return true; }不难写出如下代码：
class Solution { private: vector<vector<string>> result; vector<string> path; // 放已经回文的子串 void backtracking (const string& s, int startIndex) { // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了 if (startIndex >= s.size()) { result.push_back(path); return; } for (int i = startIndex; i < s.size(); i++) { if (isPalindrome(s, startIndex, i)) { // 是回文子串 // 获取[startIndex,i]在s中的子串 string str = s.substr(startIndex, i - startIndex + 1); path.push_back(str); } else { // 不是回文，跳过 continue; } backtracking(s, i + 1); // 寻找i+1为起始位置的子串 path.pop_back(); // 回溯过程，弹出本次已经添加的子串 } } bool isPalindrome(const string& s, int start, int end) { for (int i = start, j = end; i < j; i++, j--) { if (s[i] != s[j]) { return false; } } return true; } public: vector<vector<string>> partition(string s) { result.clear(); path.clear(); backtracking(s, 0); return result; } };
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n^2)
优化
上面的代码还存在一定的优化空间, 在于如何更高效的计算一个子字符串是否是回文字串。上述代码
isPalindrome函数运用双指针的方法来判定对于一个字符串s, 给定起始下标和终止下标, 截取出的子字符串是否是回文字串。但是其中有一定的重复计算存在:例如给定字符串
"abcde", 在已知"bcd"不是回文字串时, 不再需要去双指针操作"abcde"而可以直接判定它一定不是回文字串。具体来说, 给定一个字符串
s, 长度为n, 它成为回文字串的充分必要条件是s[0] == s[n-1]且s[1:n-1]是回文字串。大家如果熟悉动态规划这种算法的话, 我们可以高效地事先一次性计算出, 针对一个字符串
s, 它的任何子串是否是回文字串, 然后在我们的回溯函数中直接查询即可, 省去了双指针移动判定这一步骤.具体参考代码如下:
class Solution { private: vector<vector<string>> result; vector<string> path; // 放已经回文的子串 vector<vector<bool>> isPalindrome; // 放事先计算好的是否回文子串的结果 void backtracking (const string& s, int startIndex) { // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了 if (startIndex >= s.size()) { result.push_back(path); return; } for (int i = startIndex; i < s.size(); i++) { if (isPalindrome[startIndex][i]) { // 是回文子串 // 获取[startIndex,i]在s中的子串 string str = s.substr(startIndex, i - startIndex + 1); path.push_back(str); } else { // 不是回文，跳过 continue; } backtracking(s, i + 1); // 寻找i+1为起始位置的子串 path.pop_back(); // 回溯过程，弹出本次已经添加的子串 } } void computePalindrome(const string& s) { // isPalindrome[i][j] 代表 s[i:j](双边包括)是否是回文字串 isPalindrome.resize(s.size(), vector<bool>(s.size(), false)); // 根据字符串s, 刷新布尔矩阵的大小 for (int i = s.size() - 1; i >= 0; i--) { // 需要倒序计算, 保证在i行时, i+1行已经计算好了 for (int j = i; j < s.size(); j++) { if (j == i) {isPalindrome[i][j] = true;} else if (j - i == 1) {isPalindrome[i][j] = (s[i] == s[j]);} else {isPalindrome[i][j] = (s[i] == s[j] && isPalindrome[i+1][j-1]);} } } } public: vector<vector<string>> partition(string s) { result.clear(); path.clear(); computePalindrome(s); backtracking(s, 0); return result; } };总结
这道题目在leetcode上是中等，但可以说是hard的题目了，但是代码其实就是按照模板的样子来的。
那么难究竟难在什么地方呢？
- 切割问题可以抽象为组合问题
- 如何模拟那些切割线
- 切割问题中递归如何终止
- 在递归循环中如何截取子串
- 如何判断回文
class Solution {
bool check(string s){
int i = 0 , j = s.length() - 1;
while(i < j){
if(s[i ++] != s[j --]) return false;
}
return true;
}
public:
vector<vector<string>> partition(string s) {
vector<vector<string>> res;//res、path要定义为全局变量
vector<string> path;
auto dfs = [&](this auto&& dfs , int startIndex )->void{
if(startIndex == s.length()){
res.push_back(path);
return;
}
for (int i = startIndex; i < s.length(); i++) {
string s1 = s.substr(startIndex , i - startIndex + 1);
if(check(s1)) {
path.push_back(s1);
dfs(i + 1);
path.pop_back();
}
}
};
dfs(0);
return res;
}
};
106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
代码随想录法，了解大致思路：
那么代码应该怎么写呢？
说到一层一层切割，就应该想到了递归。
来看一下一共分几步：
第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间
不难写出如下代码：（先把框架写出来）
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; } // 第四步：切割中序数组，得到 中序左数组和中序右数组 // 第五步：切割后序数组，得到 后序左数组和后序右数组 // 第六步 root->left = traversal(中序左数组, 后序左数组); root->right = traversal(中序右数组, 后序右数组); return root; }难点大家应该发现了，就是如何切割，以及边界值找不好很容易乱套。
此时应该注意确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭，这个就是不变量，要在递归中保持这个不变量。
在切割的过程中会产生四个区间，把握不好不变量的话，一会左闭右开，一会左闭右闭，必然乱套！
首先要切割中序数组，为什么先切割中序数组呢？
切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。
中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：
// 找到中序遍历的切割点 int delimiterIndex; for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) { if (inorder[delimiterIndex] == rootValue) break; } // 左闭右开区间：[0, delimiterIndex) vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex); // [delimiterIndex + 1, end) vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );接下来就要切割后序数组了。
首先后序数组的最后一个元素指定不能要了，这是切割点 也是 当前二叉树中间节点的元素，已经用了。
后序数组的切割点怎么找？
后序数组没有明确的切割元素来进行左右切割，不像中序数组有明确的切割点，切割点左右分开就可以了。
此时有一个很重的点，就是中序数组大小一定是和后序数组的大小相同的（这是必然）。
中序数组我们都切成了左中序数组和右中序数组了，那么后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。
代码如下：
// postorder 舍弃末尾元素，因为这个元素就是中间节点，已经用过了 postorder.resize(postorder.size() - 1); // 左闭右开，注意这里使用了左中序数组大小作为切割点：[0, leftInorder.size) vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size()); // [leftInorder.size(), end) vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());此时，中序数组切成了左中序数组和右中序数组，后序数组切割成左后序数组和右后序数组。
接下来可以递归了，代码如下：
root->left = traversal(leftInorder, leftPostorder); root->right = traversal(rightInorder, rightPostorder);完整代码如下：
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; } // 切割中序数组 // 左闭右开区间：[0, delimiterIndex) vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex); // [delimiterIndex + 1, end) vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() ); // postorder 舍弃末尾元素 postorder.resize(postorder.size() - 1); // 切割后序数组 // 依然左闭右开，注意这里使用了左中序数组大小作为切割点 // [0, leftInorder.size) vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size()); // [leftInorder.size(), end) vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end()); 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); } };相信大家自己就算是思路清晰， 代码写出来一定是各种问题，所以一定要加日志来调试，看看是不是按照自己思路来切割的，不要大脑模拟，那样越想越糊涂。
此时应该发现了，如上的代码性能并不好，因为每层递归定义了新的vector（就是数组），既耗时又耗空间，但上面的代码是最好理解的，为了方便读者理解，所以用如上的代码来讲解。
下面给出用下标索引写出的代码版本：（思路是一样的，只不过不用重复定义vector了，每次用下标索引来分割）
class Solution { private: // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd) TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) { if (postorderBegin == postorderEnd) return NULL; int rootValue = postorder[postorderEnd - 1]; TreeNode* root = new TreeNode(rootValue); if (postorderEnd - postorderBegin == 1) return root; int delimiterIndex; for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) { if (inorder[delimiterIndex] == rootValue) break; } // 切割中序数组 // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd) int leftInorderBegin = inorderBegin; int leftInorderEnd = delimiterIndex; // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd) int rightInorderBegin = delimiterIndex + 1; int rightInorderEnd = inorderEnd; // 切割后序数组 // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd) int leftPostorderBegin = postorderBegin; int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd) int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin); int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了 root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd); root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd); return root; } public: TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { if (inorder.size() == 0 || postorder.size() == 0) return NULL; // 左闭右开的原则 return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size()); } };
运用cpp新特性，简写法：
中序遍历：按照「左子树-根-右子树」的顺序遍历二叉树。
后序遍历：按照「左子树-右子树-根」的顺序遍历二叉树。
我们来看看示例 1 是怎么生成这棵二叉树的。
递归边界：如果 postorder 的长度是 0（此时 inorder 的长度也是 0），对应着空节点，返回空。
写法一
所有区间都是「左闭右开区间」，
inorder.begin() + left_size恰好是postorder.back()的位置class Solution { public: TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { if (postorder.empty()) { // 空节点 return nullptr; } int left_size = ranges::find(inorder, postorder.back()) - inorder.begin(); // 左子树的大小 vector<int> in1(inorder.begin(), inorder.begin() + left_size); vector<int> in2(inorder.begin() + left_size + 1, inorder.end()); vector<int> post1(postorder.begin(), postorder.begin() + left_size); vector<int> post2(postorder.begin() + left_size, postorder.end() - 1); TreeNode* left = buildTree(in1, post1);//(调用原函数自身) TreeNode* right = buildTree(in2, post2); return new TreeNode(postorder.back(), left, right); } };复杂度分析
- 时间复杂度：O(n^2)，其中 n 为 postorder 的长度。最坏情况下二叉树是一条链，我们需要递归 O(n) 次，每次都需要 O(n) 的时间查找 postorder[n−1] 和复制数组。
- 空间复杂度：O(n^2)。
写法二
上面的写法有两个优化点：
- 用一个哈希表（或者数组）预处理
inorder每个元素的下标，这样就可以 O(1) 查到 postorder[n−1] 在inorder的位置，从而 O(1) 知道左子树的大小。- 把递归参数改成子数组下标区间（左闭右开区间）的左右端点，从而避免复制数组。
class Solution { public: TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { int n = inorder.size(); unordered_map<int, int> index; for (int i = 0; i < n; i++) { index[inorder[i]] = i; } auto dfs = [&](this auto&& dfs, int in_l, int in_r, int post_l, int post_r) -> TreeNode* { if (post_l == post_r) { // 空节点 return nullptr; } int left_size = index[postorder[post_r - 1]] - in_l; // 左子树的大小 TreeNode* left = dfs(in_l, in_l + left_size, post_l, post_l + left_size); TreeNode* right = dfs(in_l + left_size + 1, in_r, post_l + left_size, post_r - 1); return new TreeNode(postorder[post_r - 1], left, right); }; return dfs(0, n, 0, n); // 左闭右开区间 } };复杂度分析
- 时间复杂度：O(n)，其中 n 为 inorder 的长度。递归 O(n) 次，每次只需要 O(1) 的时间。
- 空间复杂度：O(n)。
注：由于哈希表常数比数组大，实际运行效率可能不如写法一。
构造系列
这三题都可以用本文讲的套路解决。
105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）
做法同上题：
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
if(preorder.empty()) return nullptr;
int left_size = ranges::find(inorder , preorder.front()) - inorder.begin();
vector<int> in1(inorder.begin() , inorder.begin() + left_size);
vector<int> in2(inorder.begin() + left_size + 1 , inorder.end());
vector<int> pre1(preorder.begin() + 1, preorder.begin() + 1 + left_size);
vector<int> pre2(preorder.begin() + 1 + left_size , preorder.end());
TreeNode* left = buildTree(pre1 , in1);
TreeNode* right = buildTree(pre2 , in2);
return new TreeNode(preorder.front() , left , right);
}
};
889. 根据前序和后序遍历构造二叉树 - 力扣（LeetCode）
前序遍历：按照「根-左子树-右子树」的顺序遍历二叉树。
后序遍历：按照「左子树-右子树-根」的顺序遍历二叉树。
首先说明，如果只知道前序遍历和后序遍历，这棵二叉树不一定是唯一的，如下图。
对于这两棵二叉树：
- 前序遍历都是 [1,2,3,4]。
- 后序遍历都是 [3,4,2,1]。
注：如果二叉树的每个非叶节点都有两个儿子，知道前序和后序就能唯一确定这棵二叉树。
题目说，如果存在多个答案，我们可以返回其中任何一个。那么不妨规定：无论什么情况，在前序遍历中，preorder[1] 都是左子树的根节点值。
来看看示例 1 是怎么生成这棵二叉树的。
递归边界：
- 如果 preorder 的长度是 0，对应着空节点，返回空。
- 如果 preorder 的长度是 1，对应着二叉树的叶子，创建一个叶子节点并返回。
写法一
class Solution {
public:
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
if (preorder.empty()) { // 空节点
return nullptr;
}
if (preorder.size() == 1) { // 叶子节点
return new TreeNode(preorder[0]);
}
int left_size = ranges::find(postorder, preorder[1]) - postorder.begin() + 1; // 左子树的大小
vector<int> pre1(preorder.begin() + 1, preorder.begin() + 1 + left_size);
vector<int> pre2(preorder.begin() + 1 + left_size, preorder.end());
vector<int> post1(postorder.begin(), postorder.begin() + left_size);
vector<int> post2(postorder.begin() + left_size, postorder.end() - 1);
TreeNode* left = constructFromPrePost(pre1, post1);
TreeNode* right = constructFromPrePost(pre2, post2);
return new TreeNode(preorder[0], left, right);
}
};
复杂度分析
- 时间复杂度：O(n^2)，其中 n 为 preorder 的长度。最坏情况下二叉树是一条链，我们需要递归 O(n) 次，每次都需要 O(n) 的时间查找 preorder[1] 和复制数组。
- 空间复杂度：O(n^2)。
写法二
上面的写法有两个优化点：
- 用一个哈希表（或者数组）预处理 postorder 每个元素的下标，这样就可以 O(1) 查到 preorder[1] 在 postorder 的位置，从而 O(1) 知道左子树的大小。
- 把递归参数改成子数组下标区间（左闭右开区间）的左右端点，从而避免复制数组。
class Solution {
public:
TreeNode* constructFromPrePost(vector<int>& preorder, vector<int>& postorder) {
int n = preorder.size();
vector<int> index(n + 1);
for (int i = 0; i < n; i++) {
index[postorder[i]] = i;
}
// 注意 post_r 可以省略
auto dfs = [&](this auto&& dfs, int pre_l, int pre_r, int post_l) -> TreeNode* {
if (pre_l == pre_r) { // 空节点
return nullptr;
}
if (pre_l + 1 == pre_r) { // 叶子节点
return new TreeNode(preorder[pre_l]);
}
int left_size = index[preorder[pre_l + 1]] - post_l + 1; // 左子树的大小
TreeNode* left = dfs(pre_l + 1, pre_l + 1 + left_size, post_l);
TreeNode* right = dfs(pre_l + 1 + left_size, pre_r, post_l + left_size);
return new TreeNode(preorder[pre_l], left, right);
};
return dfs(0, n, 0); // 左闭右开区间
}
};
复杂度分析
- 时间复杂度：O(n)，其中 n 为 preorder 的长度。递归 O(n) 次，每次只需要 O(1) 的时间。
- 空间复杂度：O(n)。
浙公网安备 33010602011771号