目录
一、根据二叉树构建字符串
除了根节点之外的每个节点值转换为字符串时都要用括号括起来；
当左节点为空并且右节点不为空时，左节点这个空值要用括号括起来；否则和一种情况无法区分：左不为空但是右为空，此时只需要一个括号将左节点值括起来；
class Solution {
public:
string tree2str(TreeNode* root) {
string str;
if(!root) return str;
str += to_string(root->val);
//左子树不为空，需要括号；左子树为空但是右子树不为空，左边也需要括号
if(root->left || root->right)
{
str += '(';
str += tree2str(root->left);
str += ')';
}
//=右子树为空不加，反之加括号
if(root->right)
{
str += '(';
str += tree2str(root->right);
str += ')';
}
return str;
}
};二、二叉树的层序遍历
每层都要单独的放在一个vector里面；
为了实现，设置一个变量，这个变量记录了每一层的数据个数，再用一个循环，循环变量次，每次都访问队列数据，并且进下一层数据，直到这层数据弄完；
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> vv;
if(!root) return vv;//空树返回空的vector
queue<TreeNode*> q;
q.push(root);
int Levelsize = 1;
vector<int> v;
while(Levelsize)
{
while(Levelsize--)
{
TreeNode* front = q.front();
q.pop();//记得删数据
v.push_back(front->val);
if(front->left)
q.push(front->left);
if(front->right)
q.push(front->right);
}
vv.push_back(v);
Levelsize = q.size();
v.clear();
}
reverse(vv.begin(),vv.end());//翻转结果就是正确答案
return vv;
}
};三、二叉树的最近公共祖先
方法一：
// //当p、q这两个节点分别位于一个节点的左子树、右子树时，这个节点就是
// //最近公共祖先节点
// //要么当前节点就是p、q中的某一个，此时最直接返回这个节点即可
// //递归的方式：每次查找一个节点的左右子树，观察p、q所在位置
// //当两个节点在同一边子树时，再从这个子树的根节点开始寻找
bool Intree(TreeNode*& root, TreeNode*& fund)
{
if(!root) return false;
if(root == fund) return true;
return Intree(root->left, fund) ||
Intree(root->right, fund);
}
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(!root) return nullptr;
if(root == p || root == q) return root;//处理特殊情况
bool pinleft = Intree(root->left, p);
bool pinright = !pinleft;//不在左就在右
bool qinleft = Intree(root->left, q);
bool qinright = !qinleft;
//一左一右直接返回
if((pinleft && qinright) || (pinright && qinleft))
return root;
else if(pinright && qinright)//都在右到右开始找
return lowestCommonAncestor(root->right, p, q);
else if(pinleft && qinleft)
return lowestCommonAncestor(root->left, p ,q);
return nullptr;
}
};方法二：
//上述方法每层递归判断在左还是右效率低下，方法二不需要逐层找，最坏所有路径找一次
//方法二：
//从根节点查找p、q节点所在的路径
//找到两个的路径之后转换为链表相交的问题，找到相交的节点返回即可
class Solution {
public:
bool Getpath(TreeNode*& root, TreeNode*&x, stack<TreeNode*>& st)
{
//前序寻找节点，边找边入节点形成路径
if(!root)
return false;
st.push(root);//先入再判断，就算是一个也是路径
//判断是前序，根左右
if(root == x) return true;
if(Getpath(root->left, x, st))
return true;
if(Getpath(root->right, x, st))
return true;
st.pop();
return false;
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
//若是根节点就是p、q中的一个就直接返回
if(root == q || root == p) return root;
stack<TreeNode*> proad, qroad;
Getpath(root, p, proad);
Getpath(root, q, qroad);
while(proad.size() != qroad.size())//先到相同长度
{
if(proad.size() > qroad.size())
proad.pop();
else qroad.pop();
}
while(proad.top() != qroad.top())//再找相同值
{
proad.pop();
qroad.pop();
}
return proad.top();
}
};四、将二叉搜索树转为排序的双向链表
方法一：递归
设置一个prev记录中序遍历的上一个节点，cur是当前中序遍历的节点，改变这两个指针的指向就能实现；
class Solution {
public:
void InorderConvert(Node* cur, Node*& prev)
{
if(cur == nullptr)
return;
InorderConvert(cur->left, prev);
cur->left = prev;
if(prev)
prev->right = cur;
prev = cur;
InorderConvert(cur->right, prev);
}
Node* treeToDoublyList(Node* root) {
if(root == nullptr)
return nullptr;
Node* prev = nullptr;
InorderConvert(root, prev);
Node* head = prev;
while(head->left)
{
head = head->left;
}
head->left = prev;
prev->right = head;
return head;
}
};方法二：非递归
这里的cur只是为了完成中序遍历，改变指向的指针为top和prev
public:
Node* treeToDoublyList(Node* root) {
if(root == nullptr)
return nullptr;
stack<Node*> st;
Node* prev = nullptr, *cur = root;
while(cur || !st.empty())
{
while(cur)
{
st.push(cur);
cur = cur->left;
}
//访问根节点
Node* top = st.top();
top->left = prev;
if(prev)
prev->right = top;
prev = top;
st.pop();
cur = top->right;
}
Node* head = prev;
while(head->left)
{
head = head->left;
}
head->left = prev;
prev->right = head;
return head;
}
}
五、从前序中序或者中序后序序列构建二叉树
1、通过中序和前序序列构建一颗二叉树
前序确定根，之后看中序，确定根的左子树和右子树；每一次都是如此
class Solution {
public:
TreeNode* build(vector<int>& preorder,vector<int>& inorder,int& pre,int inbegin,int inend)
{
if(inbegin>inend)
{
return nullptr;
}
TreeNode* root=new TreeNode(preorder[pre]);
int rooti=inbegin;//找每次中序的根节点
while(rooti<=inend)
{
if(preorder[pre]==inorder[rooti])
{
break;
}
else
{
rooti++;
}
}
//跳出循环找到了每次中序的根节点，分割这个数组，找出左子树和右子树
pre++;
root->left=build(preorder,inorder,pre,inbegin,rooti-1);
root->right=build(preorder,inorder,pre,rooti+1,inend);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int pre=0;
int inbegin=0;
int inend=preorder.size()-1;
return build(preorder,inorder,pre,inbegin,inend);
}
};每次进入build，先不看第一个if语句；创建根节点，也就是前序序列的第一个值去创建根节点；之后定义一个变量rooti，这个变量是在中序序列里面找和前序序列根相同的值，找到了，这个rooti就是分割左子树和右子树的分割点；
分割之后，让pre加加，保证下一个根节点是后面的序列值，这也是为什么pre要传引用的原因；
左子树和右子树各有一个区间，让此时root的左子树等于这个左子树区间的序列去构造，利用递归的思想；右子树也是；
无需担心每次递归根节点出问题，每次pre++之后保证了根节点的正确；
第一个if语句是递归结束条件，当一次递归时，构建子树序列的左边界和右边界大小不合理时就结束；
2、通过中序和后序序列构建一颗二叉树
后序确定根，和前序不同的是，它是从后面开始的，中序确定右子树和左子树，这里先是右子树构建，因为后序是：左子树 右子树 根，所以和根节点相连的是右子树
TreeNode* build(vector<int>& inorder, vector<int>& postorder,int& post,int inbegin,int inend)
{
if(inbegin>inend)
{
return nullptr;
}
TreeNode* root=new TreeNode(postorder[post]);
int rooti=inend;
while(rooti>=inbegin)
{
if(postorder[post]==inorder[rooti])
{
break;
}
else
{
rooti--;
}
}
post--;
root->right=build(inorder,postorder,post,rooti+1,inend);
root->left=build(inorder,postorder,post,inbegin,rooti-1);
return root;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
int inend=(int)(postorder.size()-1);
return build(inorder,postorder,inend,0,inend);
}思想和前序相同，只是后序是从后面开始的，并且根之后先是右子树，因为根节点所处的post--之后是右子树得到根节点的值
六、二叉树的非递归遍历-前中后
###实现非递归遍历二叉树时，要结合递归遍历的思想，访问完后面的节点要往前调；所以在实现时，用到了容器适配器栈，栈是先进后出的，那么就可以找到前面的节点；
1、定义节点结构
#include<iostream>
#include<stack>
using namespace std;
template<class T>
struct BTNode
{
BTNode(const T& val=T())
{
_val = val;
_left = _right = nullptr;
}
T _val;
BTNode<T>* _left;
BTNode<T>* _right;
};2、前序遍历
//前序遍历非递归：先根再左节点再右节点
//思路：利用栈模拟递归
//那么先进所有的左路节点，
//一边进一边访问这个作为根节点的左路节点
//只到左路节点为空，说明要开始访问右节点了，
//此时利用栈，取出栈顶的元素，这个栈顶元素就是右节点的根节点
//先记录栈顶元素，再删除栈顶元素，通过栈顶元素访问右节点
//右节点不为空，就继续进右子树的左路节点
template<class T>
void PreOrder(BTNode<T>* root)
{
stack<BTNode<T>*> st;
BTNode<T>* cur = root;
while (cur || !st.empty())//最开始栈为空，并且根节点为空就不会有什么序列了，所以要加条件cur
{
while (cur)
{
st.push(cur);
cout << cur->_val;
cur = cur->_left;
}
BTNode<T>* top = st.top();//top左节点为空
st.pop();//删除这个节点，方便后面取到上面的左路节点
cur = top->_right;//若top的右节点为空那么下一次循环就再取栈顶的数据，
//不为空，进入嵌套循环，把top的右节点作为新的根节点，进行相同循环操作
}
}
3、中序遍历
//中序遍历：先访问左子树，再访问根节点，再访问右子树
//先进所有左路节点，进到空，开始访问根节点
//根节点访问完，通过取到栈顶数据，也就是根节点找到右子树
//右子树再进入循环继续类似操作template<class T>
void InOrder(BTNode<T>* root)
{
stack<BTNode<T>*> st;
BTNode<T>* cur = root;
while (cur || !st.empty())
{
while (cur)
{
st.push(cur);
cur = cur->_left;
}
BTNode<T>* top = st.top();//左子树为空，开始访问根节点
cout << top->_val;
st.pop();
cur = top->_right;//和前序相同的操作
}
}4、后序遍历
//后序遍历：先访问左子树再访问右子树在访问根节点
//同样地先进所有的左路节点，当左路节点的左节点为空时开始访问这个左路节点的右子树
//访问右子树要先进栈
//访问的操作是把当前节点看作是根节点
//当这个根节点的右子树为空或者右子树已经被访问之后才开始访问这个根节点；
//所以要用先记录下访问过的右节点
template<class T>
void PostOrder(BTNode<T>* root)
{
stack<BTNode<T>*> st;
BTNode<T>* cur = root;
BTNode<T>* pre = nullptr;//用于记录上一个访问过的节点
while (cur || !st.empty())
{
while (cur)
{
st.push(cur);
cur = cur->_left;
}
BTNode<T>* top = st.top();//左子树为空，看要不要开始访问根节点
if (top->_right == nullptr || top->_right == pre)//若根节点的子树节点为空，那么就直接访问根节点
//若根节点右子树是上一次访问的节点，那么说明当前的根节点的右子树节点已经访问了，那么也要开始访问根
{
cout << top->_val;
st.pop();//只有访问了才删除
pre = top;
}
else
{
cur = top->_right;//若不是，那么说明根节点的右子树还没有访问，那么记录下当前根节点的右子树，再次
//进行相同循环操作
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
