二叉树的遍历
结点类型
struct TreeNode {
int val;
TreeNode *left; //左子
TreeNode *right; //右孩子
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
1. 前序遍历(preorder traversal)
- 思想:访问根结点;前序遍历左子树;前序遍历右子树
- 代码:
void preOrder(TreeNode* proot) //先序遍历
{
if ( proot == NULL) return;
cout<<proot->val<<endl;
preOrder(proot->left);
preOrder(proot->right);
}
2. 中序遍历(inorder traversal)
- 思想:中序遍历左子树;访问根结点;中序遍历右子树。
- 代码
void inOrder( TreeNode* proot) //中序遍历
{
if ( proot == NULL) return;
inOrder(proot->left);
cout<<proot->val<<endl;
inOrder(proot->right);
}
3. 后序遍历(postorder traversal)
- 思想:后序遍历左子树;后序遍历右子树;访问根结点
- 代码
void postOrder(TreeNode* proot) //后序遍历
{
if ( proot == NULL) return;
postOrder(proot->left);
postOrder(proot->right);
cout<<proot->val<<endl;
}
4. 层次遍历
- 思想:按从上到下,从左到右的顺序依次打印结点。
- 代码:
void LevelOrderTranverse( TreeNode* proot)//层次遍历
{
if (!proot) return;
queue<TreeNode*> que;
que.push(proot);
TreeNode* curr;
while (!que.empty())
{
curr = que.front();
que.pop();
if (curr->left()) que.push(curr->left);
if (curr->right()) que.push(curr->right);
cout<<curr->val<<endl;
}
}
5. 区别
6. 根据前序遍历中序遍历重构二叉树
6.1 解法一
算法思想
由前序遍历知道根节点之后,能在中序遍历上划分出左子树和右子树。分别对中序遍历的左右子树递归进行这一过程即可建树。
代码
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
int len=vin.size();
if(len==0) return nullptr;
vector<int> pre_left,pre_right,vin_left,vin_right;
TreeNode *head=new TreeNode(pre[0]); //创建根节点,根节点是前序遍历的第一个数
int gen;
for(int i=0;i<len;i++){ //找到中序遍历根节点所在位置,存放于变量gen中
if(vin[i]==pre[0]){
gen=i;
break;
}
}
//左子树
for(int i=0;i<gen;i++){
vin_left.push_back(vin[i]);
pre_left.push_back(pre[i+1]); //先序的第一个为根节点
}
//右子树
for(int i=gen+1;i<len;i++){
vin_right.push_back(vin[i]);
pre_right.push_back(pre[i]);
}
//递归,执行上述步骤,区分子树的左、右子子树,直到叶节点
head->left=reConstructBinaryTree(pre_left,vin_left);
head->right=reConstructBinaryTree(pre_right,vin_right);
return head;
}
时间复杂度分析
时间复杂度: T(n)=2T(n/2)+O(n),求解地O(nlogn)。
6.2 解法二
和解法一思想相同,只不过更简洁。
代码
class Solution {
public:
TreeNode* rebuild(vector<int>& pre, int pre_left, int pre_right, vector<int>& vin, int vin_left, int vin_right) {
if (pre_left > pre_right||vin_left > vin_right) return nullptr;
TreeNode* root = new TreeNode(pre[pre_left]);
for (int i=vin_left; i<=vin_right; ++i) {
if (vin[i] == root->val) {
root->left = rebuild(pre, pre_left+1, pre_left+i-vin_left, vin, vin_left, i-1);
root->right = rebuild(pre, pre_left+i-vin_left+1, pre_right, vin, i+1, vin_right);
break;
}
}
return root;
}
TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
return rebuild(pre, 0, pre.size()-1, vin, 0, vin.size()-1);
}
};