C++实现二叉树相关问题（先序遍历，中序遍历，后序遍历，层序遍历，搜索二叉树、平衡二叉树、满二叉树、完全二叉树的判断，最低公共祖先，二叉树的序列化和反序列化）

题目一二叉树递归和非递归遍历

题目二如何完成二叉树的宽度（也叫层序）遍历（常见题目：求一棵二叉树的宽度）

题目四如何判断一棵二叉树是搜索二叉树(BST)？

题目四如何判断一棵二叉树是平衡二叉树(AVL)？

题目五如何判断一棵二叉树是满二叉树(FBT)？

题目六如何判断一棵二叉树是完全二叉树(CBT)？

题目七给定两个二叉树的节点node1和node2，找到他们的最低公共祖先节点

题目八在二叉树中找到一个节点的后继节点。

题目十折纸问题

关于二叉树的一些笔记。

题目一二叉树递归和非递归遍历

递归序

void RecurTree(Node *head){if (head == nullptr){return;}preOrderRecur(head -> left);preOrderRecur(head -> right);
}

递归序定义：上面的递归代码运行时，如果什么都不做，每个节点被访问的顺序。

以上二叉树的递归序为：1, 2, 4, 4, 4, 2, 5, 5, 5, 2, 1, 3, 6, 6, 6, 3, 7, 7, 7, 3, 1

基于递归序，对二叉树的遍历分为先序遍历，中序遍历和后续遍历。

先序遍历：1, 2, 4, 5, 3, 6, 7(选取第一次出现的节点值，即第一次到达节点的时候打印，二、三次到达节点时什么也不做。)

中序遍历：4, 2, 5, 1, 6, 3, 7(选取第二次出现的节点值，即第二次到达节点的时候打印，一、三次到达节点时什么也不做。)

后序遍历：4, 5, 2, 6, 7, 3, 1(选取第三次出现的节点值，即第三次到达节点的时候打印，一、二次到达节点时什么也不做。)

以下为先序遍历、中序遍历和后序遍历的非递归实现原理。方法：借助栈。

先序遍历：

① 把头节点压入栈中；

② 从栈中弹出一个节点cur；

③ 打印（处理）cur；

④ 先后压右、左节点入栈（如果有的话）；

⑤ 重复② - ④步。

中序遍历：

① 每棵子树，整棵树左边界进栈；

② 依次弹出节点的过程中打印，然后对弹出节点的右树重复以上过程；

中序遍历能使用上面方法遍历的原因，任何一棵树都可以被左边界分解掉。

后序遍历：一个栈和一个收集栈

① 把头节点压入栈中；

② 从栈中弹出一个节点cur；

③ cur压入收集栈；

④ 先后压左、右节点入栈（如果有的话）；

⑤ 重复② - ④步；

⑥ 打印收集栈。

具体代码如下：

#include <iostream>
#include <stack>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};//递归
//先序遍历
void preOrderRecur(Node *head){if (head == nullptr){return;}cout << head -> val << " ";preOrderRecur(head -> left);preOrderRecur(head -> right);
}
//中序遍历
void inOrderRecur(Node *head){if (head == nullptr){return;}inOrderRecur(head -> left);cout << head -> val << " ";inOrderRecur(head -> right);
}
//后序遍历
void posOrderRecur(Node *head){if (head == nullptr){return;}posOrderRecur(head -> left);posOrderRecur(head -> right);cout << head -> val << " ";
}//非递归，借助栈
//先序遍历
void preOrderUnRecur(Node *head){if (head != nullptr){stack<Node*> helper;helper.push(head);while(!helper.empty()){head = helper.top();cout << head -> val << " ";helper.pop();if (head -> right != nullptr){helper.push(head -> right);}if (head -> left != nullptr){helper.push(head -> left);}}}}//中序遍历
void inOrderUnRecur(Node *head){if (head != nullptr){stack<Node*> helper;while(!helper.empty() || head != nullptr){if (head != nullptr){helper.push(head);head = head -> left;}else {head = helper.top();cout << head -> val << " ";helper.pop();head = head -> right;}          }}
}//后序遍历
void posOrderUnRecur(Node *head){if (head != nullptr){stack<Node*> helper1;stack<Node*> helper2;helper1.push(head);while(!helper1.empty()){head = helper1.top();helper2.push(head);helper1.pop();if (head -> left != nullptr){helper1.push(head -> left);}if (head -> right != nullptr){helper1.push(head -> right);}}while (!helper2.empty()){cout << helper2.top() -> val << " ";helper2.pop();}}
}int main(){Node *head = new Node(5);head -> left = new Node(3);head -> right = new Node(8);head -> left -> left = new Node(2);head -> left -> right = new Node(4);head -> left -> left -> left = new Node(1);head -> right -> left = new Node(5);head -> right -> right = new Node(9);head -> right -> right -> right = new Node(7);preOrderRecur(head);cout << endl;preOrderUnRecur(head);cout << endl;inOrderRecur(head);cout << endl;inOrderUnRecur(head);cout << endl;posOrderRecur(head);cout << endl;posOrderUnRecur(head);cout << endl;system("pause");
}

题目二如何完成二叉树的宽度（也叫层序）遍历（常见题目：求一棵二叉树的宽度）

层序遍历借助队列，头部进，尾部出。

① 先把头节点放入队列；

② 然后弹出就打印；

③ 弹出时先后放入该节点的左、右节点。

④ 循环② -> ③

代码如下：

#include <iostream>
#include <queue>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};void levelTraversal(Node *head){if (head != nullptr){priority_queue<Node*> helper;helper.push(head);while(!helper.empty()){head = helper.top();cout << head -> val << " ";helper.pop();if (head -> left != nullptr){helper.push(head -> left);}if (head -> right != nullptr){helper.push(head -> right); }}    }
}int main(){Node *head = new Node(5);head -> left = new Node(3);head -> right = new Node(8);head -> left -> left = new Node(2);head -> left -> right = new Node(4);head -> right -> left = new Node(5);head -> right -> right = new Node(9);levelTraversal(head);cout << endl;system("pause");
}

现在来看求二叉树的宽度

借助哈希表，记录每个节点所在的层数，然后统计层数最大的，代码如下：

#include <iostream>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};int getMaxwidth(Node *head){if (head == nullptr){return 0;}int maxWidth = 0;int curWidth = 0;int curLevel = 0;//记录每个节点对应层数的哈希表map<Node*, int> levelMap;levelMap.insert({head, 1});//借助队列实现层序遍历queue<Node*> helper;helper.push(head);while (!helper.empty()){head = helper.front();helper.pop();if (head -> left != nullptr){helper.push(head -> left);levelMap.insert({head -> left, levelMap[head] + 1});}if (head -> right != nullptr){helper.push(head -> right);levelMap.insert({head -> right, levelMap[head] + 1}); }if (levelMap[head] > curLevel){curWidth = 1;curLevel = levelMap[head];}else {curWidth++;}maxWidth = max(maxWidth, curWidth);}return maxWidth;
}int main(){Node *head = new Node(5);head -> left = new Node(3);head -> right = new Node(8);head -> left -> left = new Node(2);head -> left -> right = new Node(4);head -> left -> left -> left = new Node(1);head -> left -> left -> right = new Node(1);head -> left -> right -> left = new Node(4);head -> left -> right -> right = new Node(4);head -> right -> left = new Node(5);head -> right -> right = new Node(9);head -> right -> right -> right = new Node(7);int max = getMaxwidth(head);cout << max << endl;system("pause");
}

题目四如何判断一棵二叉树是搜索二叉树(BST)？

搜索二叉树定义：如果一棵树不为空，并且如果它的根节点左子树不为空，那么它左子树上面的所有节点的值都小于它的根节点的值，如果它的右子树不为空，那么它右子树任意节点的值都大于他的根节点的值，它的左右子树也是搜索二叉树。

解法一：中序遍历后是升序的就是搜索二叉树，将中序遍历的值存入到队列中，在判断是不是升序。对应代码中的方法1；

解法二：使用递归：

① 左子树是搜索二叉树；

② 左子树是搜索二叉树；

③ 左树max < x；

④ 右树min > x；

左树需要的信息：是不是搜索二叉树？max值？

右树需要的信息：是不是搜索二叉树？min值？

左右树均需返回的信息：是不是搜索二叉树？max值？min值？

对应代码中的方法2。

#include <iostream>
#include <vector>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};//中序遍历
void inOrderTravesal(Node *root, vector<Node*> &helper){if (root == nullptr){return;}inOrderTravesal(root -> left, helper);helper.insert(helper.end(), root);inOrderTravesal(root -> right, helper);
}bool isBST(Node *root){if (root == nullptr){return true;}vector<Node*> helper;inOrderTravesal(root, helper);int pre = INT_MIN;for (auto c : helper){if (pre >= c -> val){return false;}pre = c -> val;}return true;
}int preValue = INT_MIN;bool isBST2(Node *root){if (root == nullptr){return true;}bool isLeftBST = isBST2(root -> left);if (!isLeftBST){return false;}if (root -> val <= preValue){return false;}else {preValue = root -> val;}return isBST2(root -> right);
}int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);root -> left -> left = new Node(3);root -> left -> right = new Node(5);root -> right -> left = new Node(8);root -> right -> right = new Node(10);cout << boolalpha << isBST(root) << endl;cout << boolalpha << isBST2(root) << endl;system("pause");
}

树型DP代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};//需要知道左右子树是不是BST，左右子树的最大，最小值
struct ReturnData{bool isBST;int min;int max;ReturnData(bool is, int mi, int ma) : isBST(is), min(mi), max(ma) {}
};ReturnData* process(Node *x){if (x == nullptr){return nullptr;}ReturnData *leftData = process(x -> left);ReturnData *rightData = process(x -> right);int minData = x -> val;int maxData = x -> val;if (leftData != nullptr){minData = min(minData, leftData -> min);maxData = max(maxData, leftData -> max);}if (rightData != nullptr){minData = min(minData, rightData -> min);maxData = max(maxData, rightData -> max);}bool isBST = true;if (leftData != nullptr && (!leftData -> isBST || leftData -> max >= x -> val)){isBST = false;}if (rightData != nullptr && (!rightData -> isBST || rightData -> min <= x -> val)){isBST = false;}return new ReturnData(isBST, minData, maxData);
}int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);root -> left -> left = new Node(3);root -> left -> right = new Node(5);root -> right -> left = new Node(8);root -> right -> right = new Node(10);cout << boolalpha << process(root) -> isBST << endl;cout << process(root) -> min << endl;cout << process(root) -> max << endl;system("pause");
}

题目四如何判断一棵二叉树是平衡二叉树(AVL)？

首先了解一下平衡二叉树的定义：平衡二叉树（AVL树），它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

套用树型DP模板，需要知道的信息为：

① 左树是平衡二叉树；

② 右树是平衡二叉树；

③ 丨左高 - 右高丨 1

左树需要的信息：是不是平衡二叉树？高度？

右树需要的信息：是不是平衡二叉树？高度？

代码如下：

#include <iostream>
#include <algorithm>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};struct ReturnData{bool isAVL;int height;ReturnData(bool is, int h) : isAVL(is), height(h){}
};ReturnData* process(Node *root){if (root == nullptr){return new ReturnData(true, 0);}ReturnData *leftData = process(root -> left);ReturnData *rightData = process(root -> right);int height = max(leftData -> height, rightData -> height) + 1;bool isAVL = leftData -> isAVL && rightData -> isAVL && abs(leftData -> height - rightData -> height) < 2;return new ReturnData(isAVL, height);
}bool isAVL(Node *root){return process(root) -> isAVL;
}int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);root -> left -> left = new Node(3);root -> left -> right = new Node(5);// root -> right -> left = new Node(8);// root -> right -> right = new Node(10);cout << boolalpha << isAVL(root) << endl;system("pause");
}

题目五如何判断一棵二叉树是满二叉树(FBT)？

满二叉树定义：树中除了叶子节点，每个节点都有两个子节点。

解题方法：先统计这棵树的最大深度L，然后统计这棵树的节点个数N。若是满二叉树需满足关系。

① 左树是满二叉树；

② 右树是满二叉树；

③ 左树的信息：是不是满二叉树？深度？节点数？

④ 右树的信息：是不是满二叉树？深度？节点数？

#include <iostream>
#include <algorithm>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0),  left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};struct ReturnData{int deep;int nodes;ReturnData(int d, int n) : deep(d), nodes(n) {}
};ReturnData* process(Node *root){if (root == nullptr){return new ReturnData(0, 0);}ReturnData *leftData = process(root -> left);ReturnData *rightData = process(root -> right);int dee = max(leftData -> deep, rightData -> deep) + 1;int nod = leftData -> nodes + rightData -> nodes + 1;return new ReturnData(dee, nod);
}bool isCBT(Node *root){ReturnData *data = process(root); return data -> nodes == (1 << data -> deep) - 1;
}int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);root -> left -> left = new Node(3);root -> left -> right = new Node(5);root -> right -> left = new Node(8);// root -> right -> right = new Node(10);cout << boolalpha << isCBT(root) << endl;system("pause");
}

题目六如何判断一棵二叉树是完全二叉树(CBT)？

完全二叉树定义：一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。

解决：二叉树层序遍历

① 遇到的任何一个节点有右节点没有左节点，直接返回false；

② 在①不违规的条件下，如果遇到第一个左右节点不双全的节点，后续节点必须是都是叶节点，则为完全二叉树，否则该二叉树不是完全二叉树。

#include <iostream>
#include <queue>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};bool isCBT(Node *root){if (root == nullptr){return true;}queue<Node*> helper;bool leafNotFull = false;//是否遇到子节点不双全的情况，是为true，不是为falsehelper.push(root);while(!helper.empty()){Node *cur = helper.front();helper.pop();Node *l = cur -> left;Node *r = cur -> right;//有右节点，无左节点 => false;遇到了不双全的节点之后，又发现当前节点不是叶节点 => falseif ((l == nullptr && r != nullptr) ||(leafNotFull && (l != nullptr || r != nullptr))){return false;   }if (l != nullptr){helper.push(l);}if (r != nullptr){helper.push(r);}else {leafNotFull = true;}      }return true;
}int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);//root -> left -> left = new Node(3);//root -> left -> right = new Node(5);root -> right -> left = new Node(8);root -> right -> right = new Node(10);cout << boolalpha << isCBT(root) << endl;system("pause");
}

题目七给定两个二叉树的节点node1和node2，找到他们的最低公共祖先节点

方法一：借助哈希表。

① 在哈希表中存储每个节点和节点的父节点；

② 查找node1节点的所有父节点，存储在set结构的set1中；

③ 依次查找node2节点的父节点并判断查找到的节点是否在set1中，若存在，当前节点为最低公共祖先，不存在返回根节点。

如代码中方法1所示。

方法2：递归

o1和o2的关系只有下面两类：

① o1是o2的LCA，或者o2是o1的LCA；

② o1与o2不互为LCA，向上遍历树找到；

如代码中方法2所示。

#include <iostream>
#include <map>
#include <set>
using namespace std;struct Node{int val;Node *left;Node *right;Node() : val(0), left(nullptr), right(nullptr) {}Node(int x) : val(x), left(nullptr), right(nullptr) {}
};void process(Node *root, map<Node*, Node*> &fatherMap){if (root == nullptr){return;}fatherMap.insert({root -> left, root});fatherMap.insert({root -> right, root});process(root -> left, fatherMap);process(root -> right, fatherMap);
}//方法1
Node* lowestCommonAncestor1(Node *root, Node *o1, Node *o2){map<Node*, Node*> fatherMap;fatherMap.insert({root, root});process(root, fatherMap);set<Node*> set1;Node *cur = o1;while (cur != fatherMap[cur]){set1.insert(cur);cur = fatherMap[cur];}set1.insert(root);cur = o2;while(cur != fatherMap[cur]){if (set1.count(cur)){return cur;}cur = fatherMap[cur];}return root;
}//方法2
Node* lowestCommonAncestor2(Node *root, Node *o1, Node *o2){if (root == nullptr || root == o1 || root == o2){return root;}Node *left = lowestCommonAncestor2(root -> left, o1, o2);Node *right = lowestCommonAncestor2(root -> right, o1, o2);if (left != nullptr && right != nullptr){return root;}//左右两棵树，并不都有返回值，谁不空返回谁return left != nullptr? left : right;
}//test
int main(){Node *root = new Node(6);root -> left = new Node(4);root -> right = new Node(9);root -> left -> left = new Node(3);root -> left -> right = new Node(5);root -> right -> left = new Node(8);root -> right -> right = new Node(10);Node *o1 = root -> left -> left;Node *o2 = root -> left -> right;cout << o1 -> val << ", " << o2 -> val <<": " << endl;cout << lowestCommonAncestor1(root, o1, o2) -> val << endl;cout << lowestCommonAncestor2(root, o1, o2) -> val << endl;system("pause");
}

题目八在二叉树中找到一个节点的后继节点。

后继节点的定义：在二叉树的中序遍历序列中，node的下一个节点叫做node的后继节点。

分以下几种情况：

① x有右树的时候：后继节点为右树上的最左节点；

② x无右树的时候：依次向上遍历父节点，直到找到的父节点是其父节点y的左节点，因为这时x是y左树上最后一个打印的节点，下一个必定打印y；

③ x为整棵树最右的节点，此时x的后继节点为nullptr。

代码如下：

#include <iostream>
using namespace std;struct Node{int val;Node *left;Node *right;Node *parent;Node(int x) : val(x), left(nullptr), right(nullptr), parent(nullptr) {}
};
//获取node节点的最左节点
Node* getMostLeft(Node * node){if (node == nullptr){return node;}Node *cur = nullptr;while (node != nullptr){cur = node;node = node -> left;}return cur;
}Node* getSuccessorNode(Node* node){if (node == nullptr){return node;}if (node -> right != nullptr){return getMostLeft(node -> right);}else {Node *nodeParent = node -> parent;while(nodeParent != nullptr && nodeParent -> left != node){node = nodeParent;nodeParent = node -> parent;}return nodeParent;}return nullptr;
}
//test
int main(){Node *root = new Node(1);root -> parent = nullptr;root -> left = new Node(2);root -> left -> parent = root;root -> right = new Node(3);root -> right -> parent = root;root -> right -> left = new Node(6);root -> right -> left -> parent = root -> right;root -> right -> right = new Node(7);root -> right -> right -> parent = root -> right;cout << getSuccessorNode(root) -> val << endl;system("pause");
}

题目九二叉树的序列化和反序列化

使用先序遍历序列化和反序列化的代码如下：

#include <iostream>
#include <string>
#include <sstream>
using namespace std;struct Node{int val;Node *left;Node *right;Node(int x) : val(x), left(nullptr), right(nullptr) {}
};string serializeByPre(Node *root){if (root == nullptr){return "# ";}string res = to_string(root -> val) + " ";res += serializeByPre(root -> left);res += serializeByPre(root -> right);return res;
}Node* myDeserialize(istringstream &ans){string tmp;ans >> tmp;if (tmp == "#"){return nullptr;        }Node *root = new Node(stoi(tmp));root -> left = myDeserialize(ans);root -> right = myDeserialize(ans);return root;
}Node* deserialize(string preStr){istringstream tmp(preStr);return myDeserialize(tmp);
}

题目十折纸问题

解题思路：每折一次都会在上一次的折痕两边添加两道新的折痕，上边的折痕为凹（down)折痕，下边的折痕为凸（up)折痕。因此基于中序遍历即可解决问题。

代码如下：

#include <iostream>
#include <string>
using namespace std;//递归过程，来到了某一个节点
//i是当前节点的层数，N一共的层数，down == true ==> 凹折痕, down == false ==> 凸折痕
void printProcess(int i, int N, bool down){if (i > N){return;}printProcess(i + 1, N, true);string fold = down ? "down" : "up";cout << fold <<" ";printProcess(i + 1, N, false);
}void printAllFolds(int N){printProcess(1, N, true);
}int main(){cout << "Please Enter N: ";int N;cin >> N;printAllFolds(N);cout << endl;system("pause");
}