二叉树构建及双向链表
一、从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如,给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树:
3
/ \
9 20
/ \
15 7
代码
/**
* 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 {
private:
unordered_map<int, int> index;
public:
TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
if (preorder_left > preorder_right)
{
return nullptr;
}
// 前序遍历中的第一个节点就是根节点
int preorder_root = preorder_left;
// 在中序遍历中定位根节点
int inorder_root = index[preorder[preorder_root]];
// 先把根节点建立出来
TreeNode* root = new TreeNode(preorder[preorder_root]);
// 得到左子树中的节点数目
int size_left_subtree = inorder_root - inorder_left;
// 递归地构造左子树,并连接到根节点
// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
// 递归地构造右子树,并连接到根节点
// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = preorder.size();
// 构造哈希映射,帮助我们快速定位根节点
for (int i = 0; i < n; ++i)
{
index[inorder[i]] = i;
}
return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
}
};
二、从中序与后序遍历序列构造二叉树
根据一棵树的中序遍历与后序遍历构造二叉树。
注意:
你可以假设树中没有重复的元素。
例如,给出
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树:
3
/ \
9 20
/ \
15 7
代码
/**
* 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:
unordered_map<int, int> mp;
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder)
{
if (inorder.empty())
return NULL;
for (int i = 0; i < inorder.size(); i++)
mp[inorder[i]] = i; //记住每个数的位置
return build(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
}
TreeNode * build(vector<int>& inorder, vector<int>& postorder, int inL, int inR, int pL, int pR)
{
if (pL > pR)
return NULL;
TreeNode * root = new TreeNode(postorder[pR]);
int k = mp[postorder[pR]];
root->left = build(inorder, postorder, inL, k - 1, pL, pL + k - inL - 1);
root->right = build(inorder, postorder, k + 1, inR, pL + k - inL, pR - 1);
return root;
}
};
三、二叉搜索树转双向链表
输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点,只能调整树中结点指针的指向
。
代码
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
void BToL(TreeNode* pRootOfTree,TreeNode** Head)
{
if(pRootOfTree == nullptr)
{
return ;
}
//找到最左侧节点
TreeNode* cur = pRootOfTree;
if(cur->left)
{
BToL(cur->left,Head);
}
//cur:当前判断节点,也是双向链表当中的后一个节点
//head:当前节点的上一个节点,即cur的上一个节点,即双向链表的前一个节点
//这一步相当于双向链表当中的链接prev指针,即后一个节点链接前一个节点
cur->left = *Head;
//当第一次走到这里时cur->left肯定是空,需要判断
if(*Head)
{
//这一步相当于双向链表的next指针,即前一个节点链接后一个节点
(*Head)->right = cur;
}
//head也同步往后
*Head = cur;
//判断右子树,递归进行
if(cur->right)
{
BToL(cur->right,Head);
}
//注意随着head不断往后,得到的双向链表刚好是反的,head指针指向的位置是二叉树的最由节点
}
TreeNode* Convert(TreeNode* pRootOfTree)
{
TreeNode* Head = nullptr;
BToL(pRootOfTree,&Head);
//翻转
while(Head && Head->left)
{
Head = Head->left;
}
return Head;
}
};