二叉树-总结例题
1-从中序与后序遍历序列构造二叉树
给定二叉树的后序遍历和二叉树的中序遍历
想法：
- 先根据后序遍历的最后一个元素构造根节点
- 寻找根节点在中序遍历中的位置
- 递归构建根节点的左右子树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if(inorder.size() == 0 || postorder.size() == 0)
return NULL;
int _is = 0;
int _ie = inorder.size()-1;
int _ps = 0;
int _pe = postorder.size()-1;
return build(inorder,postorder,_is,_ie,_ps,_pe);
}
// 构建节点的递归函数
TreeNode* build(vector<int>& inorder, vector<int>& postorder,int is,int ie,int ps,int pe)
{
// 构建根节点
TreeNode* ans = new TreeNode(postorder[pe]);
int ll = 0;
int rl = 0;
for(int i = is ; i <= ie ; ++i )
{
if(inorder[i] == postorder[pe])
{
// 左子树长度
ll = i - is;
// 右子树长度
rl = ie - i;
}
}
// 构建左子树
if ( ll > 0 )
{
ans->left = build(inorder,postorder,is,is+ll-1,ps,ps+ll-1);
}
// 构建右子树
if ( rl > 0 )
{
ans->right = build(inorder,postorder,ie-rl+1,ie,pe-rl,pe-1);
}
return ans;
}
};总结：
- 返回类型为pointer，异常情况可以直接返回NULL
- 上面的代码里用了两个变量，ll和rl分别表示，左右子树在vector里面的长度。
- 每次调用递归函数，都用ll和rl改变两个容器的首尾下标。
2-从前序与中序遍历序列构造二叉树
想法：
- 先根据先序遍历的最后一个元素构造根节点
- 寻找根节点在中序遍历中的位置
- 递归构建根节点的左右子树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
return build(inorder,preorder,0,inorder.size()-1,0,preorder.size()-1);
}
TreeNode* build(vector<int>& inorder,vector<int>& preorder, int is,int ie,int ps,int pe)
{
if(inorder.size()==0 || preorder.size()==0)
{
return NULL;
}
int ll = 0 ;
int rl = 0 ;
TreeNode* ans = new TreeNode(preorder[ps]);
for(int i = is; i<= ie; i++)
{
if(preorder[ps]==inorder[i])
{
ll = i - is ;
rl = ie - i;
}
}
if ( ll > 0 )
{
ans->left = build (inorder,preorder,is,is+ll-1,ps+1 ,ps+ll );
}
if ( rl > 0 )
{
ans->right = build(inorder,preorder,ie-rl+1,ie,pe-rl+1,pe);
}
return ans;
}
};3-填充每个节点的下一个右侧节点指针（完美二叉树）
想法：
- 通过层次遍历，使用队列
- 每一层的最后一个节点指向next，否则就指向下一个
class Solution {
public:
Node* connect(Node* root) {
if( root == NULL)
return NULL;
queue<Node*> q;
q.push(root);
// 记录每一层的元素个数
while( ! q.empty())
{
int num = q.size();
// 遍历当前层（队列）里面的每个元素
for(int i = 0; i < num; i++)
{
// p指向 是队列的头节点
Node* p = q.front();
// 出队
q.pop();
// 如果到当前层最后一个元素了，next指针指向NULL，队未空，next指向队头节点
if(i == num-1)
p->next = NULL;
else
p->next = q.front();
// p 的左右孩子节点入队
if( p->left != NULL )
q.push( p->left );
if ( p->right != NULL )
q.push( p->right );
}
}
return root;
}
};4-填充每个节点的下一个右侧节点指针（非完美二叉树）
我的解法同上。
class Solution {
public:
Node* connect(Node* root) {
if( root == NULL)
return NULL;
queue<Node*> q;
q.push(root);
// 记录每一层的元素个数
while( ! q.empty())
{
int num = q.size();
// 遍历当前层（队列）里面的每个元素
for(int i = 0; i < num; i++)
{
// p指向 是队列的头节点
Node* p = q.front();
// 出队
q.pop();
// 如果到当前层最后一个元素了，next指针指向NULL，队未空，next指向队头节点
if(i == num-1)
p->next = NULL;
else
p->next = q.front();
// p 的左右孩子节点入队
if( p->left != NULL )
q.push( p->left );
if ( p->right != NULL )
q.push( p->right );
}
}
return root;
}
};5-二叉树的最近公共祖先
自己的想法 ：
- 在树中分别查找目标节点。把查找的路径存放到两个栈里。
- 其中一个栈依次出栈，在另个栈里查找这个出栈的节点。
- Note：因为搜索到的路径是唯一的。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
stack<TreeNode*> A;
stack<TreeNode*> B;
find(root,p,A);
find(root,q,B);
vector<int> bb;
for(int i = 0; i< B.size();++i)
{
bb.push_back(B.top()->val);
B.pop();
}
while(!A.empty())
{
TreeNode* ans = A.top();
for(int i = 0 ; i< bb.size();++i)
{
if( ans->val == bb[i])
return ans;
}
}
return NULL;
}
void find (TreeNode* root ,TreeNode* target, stack<TreeNode*> &ss)
{
if (! root)
return ;
if(root->val == target->val)
{
ss.push(root);
}
if(root->left != NULL)
{
vector<int> lv = dfs(root->left);
for(int i = 0; i < lv.size() ; ++i )
{
if(lv[i] == target->val)
{
ss.push(root->left);
find(root->left,target ,ss);
}
}
}
if(root->right != NULL)
{
vector<int> rv = dfs(root->right);
for(int i = 0; i < rv.size() ; ++i )
{
if(rv[i] == target->val)
{
ss.push(root->right);
find(root->right,target,ss);
}
}
}
}
vector<int> dfs(TreeNode* root)
{
vector<int> order;
helper(root,order);
return order;
}
void helper( TreeNode* root, vector<int>& vv)
{
if(root->left!=NULL)
helper(root->left,vv);
vv.push_back(root->val);
if(root->right != NULL)
helper(root->right,vv);
}
};代码超出时间限制
看看人家的代码吧：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(!root || !p || !q)
return NULL;
vector<TreeNode*> A;
vector<TreeNode*> B;
dfs(root,p,A);
dfs(root,q,B);
TreeNode* ans ;
int len = min(A.size(),B.size());
for(int i = 0; i < len ; i++)
{
if(A[i]->val != B[i]->val)
break;
ans = A[i];
}
return ans;
}
bool dfs(TreeNode* root,TreeNode* target,vector<TreeNode*>& path)
{
if( root == target ){
path.push_back(root);
return true;
}
path.push_back(root);
if( root->left && dfs( root->left , target,path ))
return true;
if(root->right && dfs( root->right , target , path ))
return true;
// 回溯？？？
path.pop_back();
return false;
}
};问题：
- ==在深度遍历函数里，pop_back()的理解：回溯？？？==
- for循环的问题
for(int i = 0; i < len ; i++)
{
if(A[i]->val != B[i]->val)
break;
ans = A[i];
}原文地址：https://www.cnblogs.com/jiangxinyu1/p/12284995.html
时间： 2024-10-22 14:25:14