二叉树的遍历与创建
前序遍历
前序遍历伪代码：
void prevorderTraverse(TreeNode* root)
{
if (root == NULL)
return;
// 前序遍历代码
prevorderTraverse(root->left);//递归左子树
prevorderTraverse(root->right);//递归右子树
}
LeetCode297-二叉树的序列化与反序列化：输入一棵二叉树的根节点 root，要求你实现一个类，用serialize方法将二叉树序列化成字符串，用deserialize方法将序列化的字符串反序列化成二叉树
class Codec {
public:
int index=0;
//序列化
string serialize(TreeNode* root)
{
string str;
PreOrderTraverse(root,str);//前序遍历
return str;
}
//前序遍历
//将二叉树序列化为字符串，val之间用,隔开
//空节点用#表示
void PreOrderTraverse(TreeNode* root,string& str)
{
if(!root)
{
str+="#,";
return;
}
str=str+to_string(root->val)+",";//整型转换为字符串
PreOrderTraverse(root->left,str);//遍历左子树
PreOrderTraverse(root->right,str);//遍历右子树
}
//反序列化
TreeNode* deserialize(string str)
{
vector<string> vec;
split(str,vec);//按,进行字符串切分
return createTree(vec);//创建二叉树
}
//根据前序遍历结果创建一棵二叉树
TreeNode* createTree(vector<string> vec)
{
if(index==vec.size())
return NULL;
TreeNode* root=NULL;
string str=vec[index++];
if (str != "#")
{
int val=atoi(str.c_str());//字符串转为整型
root = new TreeNode(val);
root->left = createTree(vec);//创建左子树
root->right = createTree(vec);//创建右子树
}
return root;
}
//切分字符串
void split(string str,vector<string>& vec)
{
int nPos = str.find( "," );
string strTmp;
while( nPos > 0 )
{
strTmp = str.substr( 0, nPos );//字串
vec.push_back( strTmp );
str.erase( 0, nPos+1 );//删除子串
nPos = str.find( "," );
}
return;
}
};
中序遍历
中序遍历伪代码：
void inorderTraverse(TreeNode* root)
{
if (root == NULL)
return;
inorderTraverse(root->left);//递归左子树
// 中序遍历代码
inorderTraverse(root->right);//递归右子树
}
//中序遍历 //扩展的中序遍历结果不能唯一确定一棵二叉树 // 1 2 // / / \ // 2 3 1 // / // 3 //扩展的中序遍历均为#3#2#1#
后序遍历
后序遍历伪代码：
void postorderTraverse(TreeNode* root)
{
if (root == NULL)
return;
postorderTraverse(root->left);//递归左子树
postorderTraverse(root->right);//递归右子树
// 后序遍历代码
}
LeetCode297-二叉树的序列化与反序列化：输入一棵二叉树的根节点 root，要求你实现一个类，用serialize方法将二叉树序列化成字符串，用deserialize方法将序列化的字符串反序列化成二叉树
//后序遍历
class Codec
{
public:
int index=0;
//序列化
string serialize(TreeNode* root)
{
string str;
PostOrderTraverse(str,root);//后序遍历
return str;
}
//后序遍历
void PostOrderTraverse(string& str,TreeNode* root)
{
if(!root)
{
str+="#,";
return;
}
PostOrderTraverse(str,root->left);//遍历左子树
PostOrderTraverse(str,root->right);//遍历右子树
str=str+to_string(root->val)+",";
}
//反序列化
TreeNode* deserialize(string str)
{
vector<string> vec;
split(vec,str);
index=vec.size()-1;
return CreateTree(vec);
}
//根据扩展的后序遍历结果创建二叉树
//后序遍历的特点：生成树的字符串的最后一个字符，代表的就是它的根结点，倒数第二个就是它的右孩子
//从字符串后面开始推，按照根结点 -> 右结点 ->左节点 的顺序就能通过递归构造出一棵二叉树了
TreeNode* CreateTree(vector<string> vec)
{
if(index<0)
return NULL;
TreeNode* root=NULL;
string str=vec[index--];
if(str!="#")
{
int val=atoi(str.c_str());
root=new TreeNode(val);
root->right=CreateTree(vec);//创建右子树
root->left=CreateTree(vec);//创建左子树
}
return root;
}
//切分字符串
void split(vector<string>& vec,string str)
{
int pos=str.find(",");
string strTemp;
while(pos>0)
{
strTemp=str.substr(0,pos);
vec.push_back(strTemp);
str.erase(0,pos+1);
pos=str.find(",");
}
return;
}
};
层序遍历
层序遍历伪代码：
void traverse(TreeNode* root)
{
if (root == NULL)
return;
// 初始化队列，将 root 加入队列
queue<TreeNode*> queue;
queue.push(root);
while (!q.empty())
{
TreeNode* cur = queue.front();
queue.pop();
//层级遍历代码
if (cur->left != NULL)
q.push(cur->left);
if (cur->right != NULL)
q.push(cur->right);
}
}
LeetCode297-二叉树的序列化与反序列化：输入一棵二叉树的根节点 root，要求你实现一个类，用serialize方法将二叉树序列化成字符串，用deserialize方法将序列化的字符串反序列化成二叉树（仅仅适用于完全二叉树）
//层序遍历,只适用于完全二叉树
class Codec
{
public:
//序列化
string serialize(TreeNode* root)
{
string str;
LevelOrderTraverse(str,root);//层序遍历
cout<<str<<endl;
return str;
}
void LevelOrderTraverse(string& str,TreeNode* root)
{
if(!root)
return;
queue<TreeNode*> que;
que.push(root);
while(!que.empty())
{
TreeNode* current=que.front();
que.pop();
str=str+to_string(current->val)+",";
if(current->left!=NULL)
que.push(current->left);
if(current->right!=NULL)
que.push(current->right);
}
}
//反序列化
TreeNode* deserialize(string str)
{
vector<string> vec;
split(vec,str);
int index=0;
return CreateTree(vec,index);
}
//根据扩展的层序遍历结果创建二叉树
TreeNode* CreateTree(vector<string> vec,int index)
{
if(index>=vec.size())
return NULL;
TreeNode* root=NULL;
string str=vec[index];
int val=atoi(str.c_str());
root=new TreeNode(val);
root->left=CreateTree(vec,2*index+1);
root->right=CreateTree(vec,2*index+2);
return root;
}
//切分字符串
void split(vector<string>& vec,string str)
{
int pos=str.find(",");
string strTemp;
while(pos>0)
{
strTemp=str.substr(0,pos);
vec.push_back(strTemp);
str.erase(0,pos+1);
pos=str.find(",");
}
return;
}
};
根据两种遍历结果确定二叉树
伪代码：
TreeNode* CreateTree(遍历结果1，遍历结果2)
{
if(遍历结果为空)
return NULL；
TreeNode* root=new TreeNode(根节点值);
if(遍历结果大小为1)
return root;
else
{
//根据根节点将遍历结果划分为
//左子树的遍历结果1，左子树的遍历结果2
//右子树的遍历结果1，右子树的遍历结果2
root->left=CreateTree(左子树的遍历结果1，左子树的遍历结果2);
root->right=CreateTree(右子树的遍历结果1，右子树的遍历结果2);
}
return root;
}
LeetCode105-前序遍历+中序遍历确定一棵二叉树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
{
if(preorder.empty()||inorder.empty()||preorder.size()!=inorder.size())
return NULL;
return CreateTree(preorder,inorder);
}
TreeNode* CreateTree(vector<int> preorder,vector<int> inorder)
{
if(preorder.empty())
return NULL;
TreeNode* root=new TreeNode(preorder[0]);
if(preorder.size()==1)
return root;
else
{
int valTemp=preorder[0];
auto pos=find(inorder.begin(),inorder.end(),valTemp);
int i=pos-inorder.begin();
vector<int> prevLeft{preorder.begin()+1,preorder.begin()+1+i};//左子树的前序遍历
vector<int> prevRight{preorder.begin()+1+i,preorder.end()};//右子树的前序遍历
vector<int> inLeft{inorder.begin(),inorder.begin()+i};//左子树的中序遍历
vector<int> inRight{inorder.begin()+i+1,inorder.end()};//右子树的中序遍历
root->left=CreateTree(prevLeft,inLeft);//创建左子树
root->right=CreateTree(prevRight,inRight);//创建右子树
}
return root;
}
};
LeetCode889-前序遍历+后序遍历确定一棵二叉树的任意一种情况
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post)
{
if(pre.empty()||post.empty()||pre.size()!=post.size())
return NULL;
return CreatTree(pre,post);
}
//前序遍历的第一个元素和后序遍历的最后一个元素为根节点
//前序遍历的第二个元素为左子树的根节点
//后序遍历的倒数第二个元素为右子树的根节点
//根据左右子树根结点的值可以将整个遍历结果切分为左/右子树的前/后序遍历
TreeNode* CreatTree(vector<int>& pre,vector<int>& post)
{
TreeNode* root=NULL;
if(pre.empty())
return NULL;
root=new TreeNode(pre[0]);
if(pre.size()==1)
return root;
else
{
//valLeft左子树根结点的值
int valLeft=pre[1];
auto pos=find(post.begin(),post.end(),valLeft);
int i=pos-post.begin()+1;//左子树有i个元素
vector<int> preLeft{pre.begin()+1,pre.begin()+1+i};//左子树的前序遍历
vector<int> postLeft{post.begin(),post.begin()+i};//左子树的后序遍历
vector<int> preRight{pre.begin()+1+i,pre.end()};//右子树的前序遍历
vector<int> postRight{post.begin()+i,post.end()-1};//右子树的后序遍历
//递归创建左右子树
root->left=CreatTree(preLeft,postLeft);
root->right=CreatTree(preRight,postRight);
}
return root;
}
};
LeetCode106-中序遍历+后序遍历确定一棵二叉树
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} * }; */ class Solution { public: TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { if(inorder.empty()||postorder.empty()||inorder.size()!=postorder.size()) return NULL; return CreateTree(inorder,postorder); } TreeNode* CreateTree(vector<int> inorder,vector<int> postorder) { if(inorder.empty()) return NULL; TreeNode* root=new TreeNode(postorder[postorder.size()-1]); if(inorder.size()==1) return root; else { int valTemp=postorder[postorder.size()-1]; auto pos=find(inorder.begin(),inorder.end(),valTemp); int i=pos-inorder.begin(); vector<int> inLeft{inorder.begin(),inorder.begin()+i}; vector<int> inRight{inorder.begin()+i+1,inorder.end()}; vector<int> postLeft{postorder.begin(),postorder.begin()+i}; vector<int> postRight{postorder.begin()+i,postorder.end()-1}; root->left=CreateTree(inLeft,postLeft); root->right=CreateTree(inRight,postRight); } return root; } };
