二叉树的遍历（递归+迭代）
二叉树的操作
- 前序遍历
-
- 递归实现
- 迭代实现
- 中序遍历
-
- 递归实现
- 迭代实现
- 后序遍历
-
- 递归实现
- 迭代实现
- 二叉树层序遍历
- 二叉树最大深度
- 对称二叉树
- 路径总和
- 从中序与后序遍历序列构造二叉树
- 从前序与中序遍历序列构造二叉树
- 二叉树最近公共祖先
- 二叉树序列化和反序列化
-
- 序列化
- 反序列化
二叉树节点定义如下：
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
前序遍历
前序遍历 首先访问根节点，然后遍历左子树，最后遍历右子树。
递归实现
//思路1：递归实现 比较简单
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
frontSearch(res,root);
return res;
}
void frontSearch(vector<int>& res,TreeNode* root){
if(root == NULL){
return ;
}
else{
res.push_back(root->val);
frontSearch(res,root->left);
frontSearch(res,root->right);
}
}
迭代实现
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode *> visit;
if(root == NULL){return res;}
while(root != NULL || visit.empty() == false){
if(root != NULL){//在这个过程中会先保存根节点值，以及左子节点值
res.push_back(root->val);//得到当前根节点值
visit.push(root); //在栈中保存，当左子树扫描完弹出扫描右子树
root = root->left;//找下一个左子树，继续上面操作
}
else{ //左子树完了，弹出找右子树
root = visit.top();
visit.pop();
root = root->right;
}
}
return res;
}
//思路2：迭代实现 另一种写法 逆序保存
vector<int> preorderTraversal(TreeNode* root){
vector<int> res;
if(root == nullptr){return res;}
stack<TreeNode *> visit;
visit.push(root);
while(!visit.empty()){
root = visit.top();
visit.pop();
res.push_back(root->val);
if(root->right != nullptr){visit.push(root->right);}
if(root->left != nullptr){visit.push(root->left);}
}
return res;
}
中序遍历
中序遍历 是先遍历左子树，然后访问根节点，然后遍历右子树。
递归实现
//思路1：递归实现
vector<int> inorderTraversal(TreeNode* root) {
vector<int> value;
middleSearch(value,root);
return value;
}
void middleSearch(vector<int> &value,TreeNode* root){
if(root == NULL){
return;
}
else{
middleSearch(value,root->left);
value.push_back(root->val);
middleSearch(value,root->right);
}
}
迭代实现
vector<int> inorderTraversal(TreeNode* root){
vector<int> res;
if(root == NULL) {return res;}
stack<TreeNode*> visit;
while(root != NULL || !visit.empty()){
if(root != NULL){//不为空，加入栈中并找左子树 一直向左，添加所有的左子树值
visit.push(root);
root = root->left;
}
else{
root = visit.top();//弹出栈最顶节点 此时是最左那个节点
visit.pop();
res.push_back(root->val);
root = root->right; //从右子树节点继续找看是否有左子树
}
}
return res;
}
后序遍历
后序遍历 是先遍历左子树，然后遍历右子树，最后访问树的根节点。
递归实现
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
backSearch(res,root);
return res;
}
void backSearch(vector<int>& res,TreeNode* root){
if(root == NULL){return;}
backSearch(res,root->left);
backSearch(res,root->right);
res.push_back(root->val);
}
迭代实现
//思路2：迭代实现 修改前序遍历代码，将遍历左右子树的顺序对调，
// 即可用栈保存一个根节点->右子树->左子树的遍历序列，然后反序输出即可
vector<int> postorderTraversal(TreeNode* root){
vector<int> res;
if(root == NULL){return res;}
stack<TreeNode*>visit;
stack<int> temp;
while(root != NULL || !visit.empty()){
if(root != NULL){//在这个过程中会先保存根节点值，以及右子节点值
temp.push(root->val);
visit.push(root);
root = root->right;
}
else{
root = visit.top();
visit.pop();
root = root->left;
}
}
while(!temp.empty()){ //将结果反序输出
res.push_back(temp.top());
temp.pop();
}
return res;
}
二叉树层序遍历
思路：创建一个队列，先将根节点（A）入队，然后用front指针将根节点记下来，再将根节点出队，接下来看front节点（也就是刚才的根节点）有没有左孩子或右孩子，如果有，先左（B）后右（C）入队，最后输出front节点的值，只要队列还不为空，就说明还没有遍历完，就进行下一次循环，这时的队头元素（front）则为刚才入队的左孩子（B），然后front出队，再把它的左右孩子拉进来（如果有
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if(root == NULL){return res;}
queue<TreeNode*> visit;
visit.push(root); //先加入根节点
while(!visit.empty()){
int size = visit.size(); //记录每一层节点数
vector<int> temp;//保存临时一层节点值
while(size > 0){
TreeNode * front = visit.front();
temp.push_back(front->val); //加入一层数据
visit.pop();
if(front->left != NULL){
visit.push(front->left);
}
if(front->right != NULL){
visit.push(front->right);
}
--size;
}
res.push_back(temp);
}
return res;
}
二叉树最大深度
int res = 0;
int maxDepth(TreeNode* root) {
if(root == NULL){return 0;}
findMaxDepth(root,1);
return res;
}
void findMaxDepth(TreeNode* root,int depth){
if(root == NULL){return;}
if(root->left == NULL || root->right == NULL){//搜索左子树或右子树到最低端，更新最大深度
res = max(res,depth);
}
findMaxDepth(root->left,depth+1);//递归搜索左子树，深度加1
findMaxDepth(root->right,depth+1);
}
//思路2:返回左子树和右子树最大深度 + 1(根节点是1)
int maxDepth(TreeNode* root){
if(root == NULL){return 0;}
return (1 + max(maxDepth(root->left), maxDepth(root->right)));
}
对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
//思路2：递归实现 首先以根节点以及其左右子树，左子树的左子树和右子树的右子树相同，左子树的右子树和右子树
// 的左子树相同。两个条件都要符合，所以我们第一个传根节点的左子树和右子树，先判断左右子树根结点的比较。
// 然后分辨对左子树的左子树和右子树的右子树。左子树的右子树和右子树的左子树进行判断。
// 只有两个条件都满足则返回的是true，一层一层递归进入，则可以得到结果。
bool isSymmetric(TreeNode* pRoot)
{
// 思路：首先根结点以及其左右子树，左子树的左子树和右子树的右子树相同，
// 左子树的右子树，和右子树的左子树相同。我们采用递归的方式
if(pRoot == NULL){
return true;
}
return comRoot(pRoot->left, pRoot->right);
}
bool comRoot(TreeNode* left, TreeNode* right){
if(left == NULL){
return right == NULL;
}
if(right == NULL){
return false;//能执行到这一步，说明他的左子树肯定是不为空，此时比较右子树如果为空，那么肯定返回false
}
if(left->val != right->val){
return false;
}
//能执行到这一步，说明其传进来的左子树和右子树不为null，且对应值相等，此时我们只需要，进行递归比较
//传进来的左子树的左子树和传进来右子树的右子树。传进来的左子树的右子树和传进来的右子树的左子树。
return comRoot(left->left, right->right) && comRoot(left->right, right->left);
}
路径总和
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
//思路：递归调用，每次sum减去当前节点值，然后分别看左右子树是否符合该路径和
bool hasPathSum(TreeNode* root, int sum) {
if(root == NULL){return false;}
int count = sum - root->val;
if(root->left == NULL && root->right == NULL){ //是叶子节点
return count == 0; //刚好等于零，这说明符合路径和
}
//递归调用函数，分别判断左右子树
return hasPathSum(root->left,count) || hasPathSum(root->right,count);
}
从中序与后序遍历序列构造二叉树
//思路：后续遍历最后一个是根节点，然后找到根节点后在中序遍历中左右分别为左右子树，从而递归左右子树继续上面操作
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
int len = inorder.size();
if(len == 0 || len != postorder.size()){
return nullptr;
}
TreeNode * root = nullptr;
root = buildHelper(inorder,0,len - 1,postorder,0,len-1);
return root;
}
TreeNode* buildHelper(vector<int>& inorder,int instart,int inend,vector<int>& postorder,int poststart,int postend)
{
if(instart > inend || poststart > postend){
return nullptr;
}
TreeNode* root = new TreeNode(postorder[postend]);//后续遍历最后一个是根节点
int index = 0; //记录root在中序遍历坐标
for(index = instart; index <= inend; ++index){
if(inorder[index] == postorder[postend]){//找到根节点坐标
//中序遍历左子树起点还是instart，终点是root左边即为左子树终点
//后续遍历左子树起点还是poststart，终点是poststart + 左子树的个数（即index-instart
root->left = buildHelper(inorder,instart,index-1,postorder,poststart,poststart+index-instart-1);//递归找左子树
//中序遍历右子树起点是root右边一个即index+1，终点是inend
//后续遍历右子树起点是poststart + 左子树的个数（即index-instart，终点是postend-1 即减去最右边根
root->right = buildHelper(inorder,index+1,inend,postorder,poststart+index-instart,postend-1);//递归找左子树
}
}
return root;
}
从前序与中序遍历序列构造二叉树
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int len = preorder.size();
if(len == 0 || len != inorder.size()){
return nullptr;
}
TreeNode* root = nullptr;
root = buildHelper(preorder,0,len - 1,inorder,0,len - 1);
return root;
}
TreeNode* buildHelper(vector<int>& preorder,int prestart,int preend,vector<int>& inorder,int instart,int inend)
{
if(prestart > preend || instart > inend){
return nullptr;
}
TreeNode* root = new TreeNode(preorder[prestart]);//前序遍历第一个是根节点
int index = 0; //记录root在中序遍历坐标
for(index = instart; index <= inend; ++index){
if(inorder[index] == preorder[prestart]){//找到根节点坐标
//前序遍历的左子树起点是prestart+1，终点是prestart+左子树个数(即index-instart) +1后-1，加1是第一个根节点
//中序遍历的左子树起点是instart，终点是index-1
root->left = buildHelper(preorder,prestart+1,prestart+index-instart,inorder,instart,index-1);//递归找左子树
//前序遍历的右子树起点是prestart+左子树个数(即index-instart)+1，终点是preend
//中序遍历的右子树起点是index+1，终点是inend
root->right = buildHelper(preorder,prestart+index-instart+1,preend,inorder,index+1,inend);//递归找you子树
}
}
return root;
}
二叉树最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
//思路：对于二叉树查找题大都从左右子树递归解决，需首先确定临界条件为空或是root=q、root=p，则改题简化为查找以
//root为根树上是否有p或q节点，如果有返回p或q，否则返回null，则对左右子树递归查找是否有p、q，分4种情况：
//1、左子树找到，右子树找不到，直接返回左子树查找结果；
//2、左子树找不到，右子树找到，直接返回右子树查找结果；
//3、左右子树均找到，说明p、q分居root两侧，直接返回root 在root的两侧处
//4、左右均找不到（虽然p、q节点必存在，但是递归会找子树不一定满足全局条件）返回null
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root == nullptr || root == p || root ==q){//找到了，或为空返回终止递归
return root;
}
TreeNode* left = lowestCommonAncestor(root->left,p,q);//递归找左子树
TreeNode* right = lowestCommonAncestor(root->right,p,q);
if(left == nullptr && right == nullptr){return nullptr;}
else if(left == nullptr && right != nullptr){return right;}//会根据递归一直返回该节点
else if(left != nullptr && right == nullptr){return left;}
else {return root;}//一直有左右子树节点，说明分居root两侧，返回root
}
二叉树序列化和反序列化
序列化
// Encodes a tree to a single string.
string serialize(TreeNode* root) {
if(root == nullptr){return "#";}
stringstream ss;
string cur = "";
ss<<root->val<<","<<serialize(root->left)<<","<<serialize(root->right);
ss>>cur;
return cur;
}
反序列化
// Decodes your encoded data to tree.
TreeNode* deserialize(string data) {
//string拆分数组
queue<string> temp;
int index = data.find(",");
while(index != data.npos){
temp.push(data.substr(0,index));
//cout<
data = data.substr(index + 1,data.length());
index = data.find(",");
}
temp.push(data);
//cout<
TreeNode* root = deserializeHelper(temp);
return root;
}
TreeNode* deserializeHelper(queue<string>& temp){
//if(temp.size() <= 0){return nullptr;}
string top = temp.front();
temp.pop();
if(top == "#"){return nullptr;}
else{
TreeNode* root = new TreeNode(atoi(top.c_str()));
root->left = deserializeHelper(temp);
root->right = deserializeHelper(temp);
return root;
}
}