一、根据二叉树创建字符串
思路:在正常前序递归遍历的基础上,单独加上一个考虑到右子树为空的情况,如下:其结果为 1(2(4(5)(6))),当遍历到节点2时由于2的左节点不为空,右节点为空,我们应该先打印根节点,然后打印(左子树)。
class Solution {
public:
string tree2str(TreeNode* root) {
if(root == nullptr) return "";
if(root->left == nullptr && root->right == nullptr) return to_string(root->val);
if(root->right == nullptr)
return to_string(root->val) + "(" + tree2str(root->left) + ")";
return to_string(root->val) + "(" + tree2str(root->left) + ")(" +tree2str(root->right) + ")";
}
};
二、二叉树的层序遍历
思路:
方法一BFS:
用队列来写,把每一层入队列,出队列的第一个头节点,然后把头节点所连节点加入队列中,然后循环往复,直到队列没有元素
方法二DFS:
定义一个k,ans[k]表示每层的节点数组。
方法一: BFS
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> vv;
if(root == NULL) return vv;
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
vector<int> v;
int size = q.size();
while(size--)
{
TreeNode* node = q.front();
q.pop();
v.emplace_back(node->val);
if(node->left) q.push(node->left);
if(node->right) q.push(node->right);
}
vv.push_back(v);
}
return vv;
}
};
方法二:DFS
class Solution {
public:
void dfs(TreeNode* root, int k, vector<vector<int>>& ans)
{
if (root == NULL) return;
if (k == ans.size()) ans.push_back(vector<int>());
ans[k].push_back(root->val);
dfs(root->left, k + 1, ans);
dfs(root->right, k + 1, ans);
}
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> ans;
dfs(root, 0, ans);
return ans;
}
};
三、二叉树的层序遍历II
思路:
这道题要求从下到上输出每一层的节点值,只要在层序遍历I稍作修改即可:在遍历完一层节点之后,将存储该层节点值的列表添加到结果列表的头部。
方法一、BFS
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> vv;
if(root == nullptr) return vv;
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
vector<int> v;
int n = q.size(); //每一层的节点
while(n--)
{
TreeNode* Node = q.front();
q.pop();
v.push_back(Node->val);
if(Node->left) q.push(Node->left);
if(Node->right) q.push(Node->right);
}
vv.push_back(v);
}
reverse(vv.begin(),vv.end());
return vv;
}
};
方法二:DFS
class Solution {
public:
void dfs(TreeNode* root, int k, vector<vector<int>>& ans)
{
if (root == NULL) return;
if (k == ans.size()) ans.push_back(vector<int>());
ans[k].push_back(root->val);
dfs(root->left, k + 1, ans);
dfs(root->right, k + 1, ans);
}
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> ans;
dfs(root, 0, ans);
reverse(ans.begin(), ans.end());
return ans;
}
};
四、二叉树最近公共祖先
思路:
两个节点 p,q 分为两种情况:1、 p 和 q 在相同子树
2、p 和 q 在不同子树
从根节点遍历,递归向左右子树查询节点信息。
递归终止条件:如果当前节点为空或等于 p 或 q,则返回当前节点递归遍历左右子树,如果左右子树查到节点都不为空,则表明 p 和 q 分别在左右子树中,因此,当前节点即为最近公共祖先;
如果左右子树其中一个不为空,则返回非空节点。
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root == NULL || root == p || root == q) return root;
TreeNode* l = lowestCommonAncestor(root->left, p, q); //若在左子树则不为空
TreeNode* r = lowestCommonAncestor(root->right, p, q); //若在右子树则不为空
if(l && r) return root; //不在同一棵子树
return l ? l : r; //在同一棵子树,则返回子树的根节点,即 p 或者 q
}
};
五、二叉搜索树和双向链表
思路:
1、已知将二叉搜索树进行中序遍历可以得到由小到大的顺序排列,因此本题最直接的想法就是进行中序遍历。
2、将中序遍历的结果用数组存储下来,得到的数组是有从小到大顺序的。最后将数组中的结点依次连接即可。3、但是根据题目的要求1,不能创建新的结点,而上述方法的数组中存储的其实是结点,并不满足题意;所以需要在中序遍历的过程中,直接对结点的指针进行调整。
4、调整的思路如下:(1)使用一个指针preNode指向当前结点root的前继。(例如上述图中root为指向10的时候,preNode指向8)
(2)对于当前结点root,有root->left要指向前继preNode(中序遍历时,对于当前结点root,其左孩子已经遍历完成了,此时root->left可以被修改。);同时,preNode->right要指向当前结点(当前结点是preNode的后继),此时对于preNode结点,它已经完全加入双向链表。
class Solution {
public:
TreeNode* preNode; //前继节点
TreeNode* Convert(TreeNode* pRootOfTree) {
if(pRootOfTree == nullptr) return pRootOfTree;
TreeNode* p = pRootOfTree;
while(p->left) p = p->left; //找到双向链表的开头。
Inorder(pRootOfTree);
return p;
}
void Inorder(TreeNode* root){
if(root == nullptr) return;
Inorder(root->left);
root->left = preNode;
if(preNode) preNode->right = root;
preNode = root;//更新preNode,指向当前结点,作为下一个结点的前继。
Inorder(root->right);
}
};
六、从前序遍历和中序遍历序列构建二叉树
思路:
由于前序遍历的性质可知其第一个节点为根节点,然后我们通过该根节点,再将中序遍历结果分开,再来找节点,如下图所示
DFS解法:
class Solution {
private:
unordered_map<int, int> pos;
public:
TreeNode* dfs(const vector<int>& preorder, const vector<int>& inorder, int pl, int pr, int il, int ir) {
if (pl > pr) return nullptr;
// 前序遍历中的第一个节点就是根节点
int k = pos[preorder[pl]]; // 在中序遍历中定位根节点
// 先把根节点建立出来
TreeNode* root = new TreeNode(preorder[pl]);
int len = k - il;// 得到左子树中的节点数目
// 递归地构造左子树,并连接到根节点
// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root->left = dfs(preorder, inorder, pl + 1, pl + len, il, k - 1);
// 递归地构造右子树,并连接到根节点
// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root->right = dfs(preorder, inorder, pl + len + 1, pr, k + 1, ir);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
// 构造哈希映射,帮助我们快速定位根节点
for (int i = 0; i < n; ++i) {
pos[inorder[i]] = i;
}
return dfs(preorder, inorder, 0, n - 1, 0, n - 1);
}
};
七、从中序和后序遍历序列构建二叉树
和上面代码思路差不多
class Solution {
public:
unordered_map<int, int> pos;
TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int il, int ir, int pl, int pr){
if(il > ir) return nullptr; //递归截止
int k = pos[postorder[pr]]; //中序遍历确立根位置
TreeNode* root = new TreeNode(postorder[pr]); //创立根节点
root->left = dfs(inorder, postorder, il, k - 1, pl, pl + k - 1 - il);
root->right = dfs(inorder, postorder, k + 1, ir, pl + k - il, pr - 1);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
int n = inorder.size();
for(int i = 0; i < n; i++){
pos[inorder[i]] = i; //标记二叉树祖先遍历结果所对应下标
}
return dfs(inorder, postorder, 0, n - 1, 0 , n - 1);
}
};
八、中序遍历非递归
给定一个二叉树的根节点 root
,返回 它的 中序 遍历
class Solution {
public:
vector<int> ans;
stack<TreeNode*> s;
vector<int> inorderTraversal(TreeNode* root) {
while(root != nullptr || !s.empty()){
while(root != nullptr){
s.push(root);
root = root->left;
}
root = s.top(); //取出第一个元素
s.pop();
ans.push_back(root->val);
root = root -> right;
}
return ans;
}
};
九、后序遍历非递归
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
stack<TreeNode*> s;
TreeNode* pre = nullptr;
while(root != nullptr || !s.empty()){
while(root != nullptr){
s.push(root);
root = root->left;
}
root = s.top(); //取出第一个元素
s.pop();
if (root->right == nullptr || root->right == pre) {
ans.push_back(root->val);
pre = root;
root = nullptr;
}
else {
s.push(root);
root = root->right;
}
}
return ans;
}
};