前序/中序/后序遍历
求后序遍历
已知前序遍历abdgcefh，中序遍历dgbaechf
根据前序确定根节点，根据中序确定子序列。再在子序列中确定父节点，以此类推。
那么，后序遍历为：gdbehfca
递归法
void inorder_traversal_dfs(TreeNode *root, vector<int> &ret) {
if (root == nullptr) return;
inorder_traversal_dfs(root->left, ret);
ret.push_back(root->val);
inorder_traversal_dfs(root->right, ret);
}
vector<int> inorder_traversal(TreeNode *root) {
vector<int> ret;
inorder_traversal_dfs(root, ret);
return ret;
}
迭代法
vector<int> inorder_traversal(TreeNode *root) {
vector<int> res;
stack < TreeNode * > stk;
while (root != nullptr || !stk.empty()) {
while (root != nullptr) {
stk.push(root);
root = root->left;
}
root = stk.top();
stk.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}
迭代法层序遍历
广度优先搜索算法 BFS：手动维护一个队列，先把根节点入队，每次出队之前，把非空的左右子结点入队。题解自 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
vector<vector<int>> level_order(TreeNode *root) {
vector<vector<int>> results;
if (!root) return results;
queue<TreeNode *> q;
q.push(root);
while (!q.empty()) {
int n = q.size();
vector<int> level(n);
for (int i = 0; i < n; i++) {
level[i] = q.front()->val;
if (q.front()->left) q.push(q.front()->left);
if (q.front()->right) q.push(q.front()->right);
q.pop();
}
results.push_back(level);
}
return results;
}
求树的深度
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if(pRoot == NULL) return 0;
return max(TreeDepth(pRoot->left), TreeDepth(pRoot->right)) + 1;
}
};
判断平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树。
class Solution {
public:
int depth(TreeNode *root) {
if (!root) return 0; // 空树也是平衡树
int l = depth(root->left); // 提前截止
if (l == -1) return -1;
int r = depth(root->right); // 提前截止
if (r == -1) return -1;
if (abs(l - r)> 1) return -1;
return max(l, r) + 1;
}
bool IsBalanced_Solution(TreeNode* root) {
return depth(root) != -1;
}
};
重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
- 递归截止：子树序列中无结点
- 由前序序列确定根结点
- 在中序序列中根据root的索引，分为左右子树
- 分别递归左子树和右子树
- 返回根节点
class Solution {
public:
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
// 递归求解
return reconstruct(pre, 0, pre.size(), vin, 0, vin.size());
}
TreeNode* reconstruct(vector<int>& pre, int pl, int pr,
vector<int>& vin, int vl, int vr){
// 前序没有结点时，迭代终止
if(pl==pr) return nullptr;
// 根节点
TreeNode* root = new TreeNode(pre[pl]);
// 确定中序遍历中根节点的索引，分为左右子树，进行递归
for(int i=vl; i<vr; ++i){
if(vin[i] == root->val){
int num = i - vl; // 左子树的结点个数
root->left = reconstruct(pre, pl+1, pl+1+num, vin, vl, i);
root->right = reconstruct(pre, pl+1+num, pr, vin, i+1, vr);
break;
}
}
return root;
}
};
滑动窗口最大值
题目描述：
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
分析：
可以用暴力遍历的方法，时间复杂度：O(n*k), 其中n为数组大小，k为窗口大小。也可以用平衡二叉树或完全二叉树(大顶堆)，这里只做试验：
平衡二叉树 map 自动排序，从小到大：将每个窗口的数据存入，删除老数据，存入新数据，读出最大的即可。
vector<int> maxInWindows(const vector<int>& num, unsigned int size) {
if (num.size() == 0 || size <= 0 || num.size() < size) return {};
vector<int> ret;
map<int, int> win; // 元素:索引
for (int i = 0; i < num.size(); ++i) {
if (win.size() < size) {
win[num[i]] = i;
if (size == win.size()) {
ret.push_back(win.rbegin()->first);
}
}
else {
win.erase(num[i - size]);
win[num[i]] = i;
ret.push_back(win.rbegin()->first);
}
}
return ret;
}
数据流的中位数
题目描述：
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
分析：
(1) 最简单的：每次插入vector，取中位数时排序 std::sort( v.begin(), v.end() );
(2) 插入的同时，进行排序：low_bound
class Solution2 {
public:
void Insert(int num)
{
if (arr.empty()) arr.push_back(num);
else {
auto it = lower_bound(arr.begin(), arr.end(), num); // lower/upper都适用
arr.insert(it, num);
}
}
double GetMedian()
{
int n = arr.size();
return n & 1 ? arr[n / 2] : (arr[n / 2 - 1] + arr[n / 2]) * 0.5;
}
private:
vector<int> arr;
};
注意：(n>>2) - 1 移位运算符的优先级低于算术运算符！！！判断奇偶可以用位运算符
(3) 利用优先队列：大顶堆+小顶堆
// 大顶堆，用来存放中位数的较小数 lows
// 小顶堆，用来存放中位数的较大数 ups
- 最开始都是空堆，属于平衡状态
- lows中存进一个数，就要转给ups一个
- 如果 lows.size() < ups.size() 说明转多了，要补回来
class Solution3 {
public:
void Insert(int num)
{
lows.emplace(num);
ups.emplace(lows.top());
lows.pop();
if (lows.size() < ups.size()) {
lows.emplace(ups.top());
ups.pop();
}
}
double GetMedian()
{
return lows.size() > ups.size() ? lows.top() : (lows.top() + ups.top()) * 0.5;
}
private:
priority_queue<int> lows;// 大顶堆，用来存放中位数的较小数
priority_queue<int, vector<int>, greater<int>> ups; // 小顶堆，用来存放中位数的较大数
};
寻找第K个结点
题目描述：
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
分析：
这题比较难。二叉搜索树的中序遍历就是将结点从小到大排序，所以第1小的结点就是遍历左子树，一直到空。想到的就是递归，遍历到叶子结点后，第i次回溯就是第i小的结点，这时要考虑右子树。
增序： 1 2 3 4
降序： 4 3 2 1
所以找第k小，就是找 k-- == 1
class Solution {
public:
TreeNode* KthNode(TreeNode* pRoot, int k)
{
this->k = k;
dfs(pRoot);
return node;
}
void dfs(TreeNode* p){
// 节点不存在或已经找到则返回
if(!p || k<1) return;
// 继续寻找左子树
dfs(p->left);
// 回溯
if(k==1) node = p;
k--;
if(p->right) dfs(p->right);
}
private:
TreeNode* node = nullptr;
int k = 1;
};
判断二叉树是否镜像
class Solution {
public:
bool isSymmetrical(TreeNode* pRoot){
return isSame(pRoot, pRoot);
}
bool isSame(TreeNode* r1, TreeNode* r2){
if(!r1 && !r2) return true; // 结点同时不存在
if(!r1 || !r2) return false; // 结点只存在一个
return r1->val == r2->val // 结点同时都存在
&& isSame(r1->left, r2->right)
&& isSame(r2->left, r1->right);
}
};
1001
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
