目录
剑指Offer（四）：重建二叉树
二、题目
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
1、思路
通常树有如下几种遍历方式：
- 前序遍历：先访问根结点，再访问左子结点，最后访问右子结点。
- 中序遍历：先访问左子结点，再访问根结点，最后访问右子结点。
- 后序遍历：先访问左子结点，再访问右子结点，最后访问根结点。
本题为前序遍历和中序遍历，最少需要两种遍历方式，才能重建二叉树。
前序遍历序列中，第一个数字总是树的根结点的值。在中序遍历序列中，根结点的值在序列的中间，左子树的结点的值位于根结点的值的左边，而右子树的结点的值位于根结点的值的右边。剩下的我们可以递归来实现，具体如图
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
if(pre.size() == 0){ //如果为空，返回NULL
return NULL;
}
//依次是前序遍历左子树，前序遍历右子树，中序遍历左子树，中序遍历右子树
vector<int> left_pre, right_pre, left_vin, right_vin;
//中序遍历第一个节点一定为根节点
TreeNode* head = new TreeNode(pre[0]);
//找到中序遍历的根节点
int root = 0;
//遍历找到中序遍历根节点索引值
for(int i = 0; i < pre.size(); i++){
if(pre[0] == vin[i]){
root = i;
break;
}
}
//利用中序遍历的根节点，对二叉树节点进行归并
for(int i = 0; i < root; i++){
left_vin.push_back(vin[i]);
left_pre.push_back(pre[i + 1]); //前序遍历第一个为根节点
}
for(int i = root + 1; i < pre.size(); i++){
right_vin.push_back(vin[i]);
right_pre.push_back(pre[i]);
}
//递归，再对其进行上述所有步骤，即再区分子树的左、右子子数，直到叶节点
head->left = reConstructBinaryTree(left_pre, left_vin);
head->right = reConstructBinaryTree(right_pre, right_vin);
return head;
}
};剑指Offer（十七）：树的子结构
题目
输入两颗二叉树A，B，判断B是不是A的子结构。（PS：我们约定空树不是任意一个树的子结构）。
1、思路
要查找树A中是否存在和树B结构一样的子树，我们可以分为两步：第一步在树A中找到和B的根结点的值一样的结点R，第二步再判断树A中以R为根节点的子树是不是包含和树B一样的结构。
这里使用递归的方法即可。
2、代码
C++：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{
bool result = false;
if(pRoot1 != NULL && pRoot2 != NULL){
if(pRoot1->val == pRoot2->val){
result = DoesTree1HasTree2(pRoot1, pRoot2);
}
if(!result){
result = HasSubtree(pRoot1->left, pRoot2);
}
if(!result){
result = HasSubtree(pRoot1->right, pRoot2);
}
}
return result;
}
private:
bool DoesTree1HasTree2(TreeNode* pRoot1, TreeNode* pRoot2){
if(pRoot2 == NULL){
return true;
}
if(pRoot1 == NULL){
return false;
}
if(pRoot1->val != pRoot2->val){
return false;
}
return DoesTree1HasTree2(pRoot1->left, pRoot2->left) && DoesTree1HasTree2(pRoot1->right, pRoot2->right);
}
};剑指Offer（十八）：二叉树的镜像
题目
如下图所示：
1、思路
先交换根节点的两个子结点之后，我们注意到值为10、6的结点的子结点仍然保持不变，因此我们还需要交换这两个结点的左右子结点。做完这两次交换之后，我们已经遍历完所有的非叶结点。此时变换之后的树刚好就是原始树的镜像。交换示意图如下所示：
2、代码
C++：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
void Mirror(TreeNode *pRoot) {
if((pRoot == NULL) || (pRoot->left == NULL && pRoot->right == NULL)){
return;
}
//交换根节点的左右结点
TreeNode *pTemp = pRoot->left;
pRoot->left = pRoot->right;
pRoot->right = pTemp;
//递归左子树
if(pRoot->left){
Mirror(pRoot->left);
}
//递归右子树
if(pRoot->right){
Mirror(pRoot->right);
}
}
};剑指Offer（二十二）：从上往下打印二叉树
题目
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
1、思路
举例说明：
如上图所示，因为按层打印的顺序决定应该先打印根结点，所以我们从树的根结点开始分析。为了接下来能够打印值为8的结点的两个子结点，我们应该在遍历该结点时把值为6和10的两个结点保存到一个容器里，现在容器内就有两个结点了。按照从左到右打印的要求，我们先取出为6的结点。打印出值6之后把它的值分别为5和7的两个结点放入数据容器。此时数据容器中有三个结点，值分别为10、5和7。接下来我们从数据容器中取出值为10的结点。注意到值为10的结点比值为5、7的结点先放入容器，此时又比这两个结点先取出，这就是我们通常说的先入先出，因此不难看出这个数据容器应该是一个队列。由于值为5、7、9、11的结点都没有子结点，因此只要依次打印即可。
整个打印过程如下图所示：
通过上面具体例子的分析，我们可以找到从上到下打印二叉树的规律：每一次打印一个结点的时候，如果该结点有子结点，则把该结点的子结点放到一个队列的末尾。接下来到队列的头部取出最早进入队列的结点，重复前面的打印操作，直至队列中所有的结点都打印出来为止。
2、代码
C++：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<int> PrintFromTopToBottom(TreeNode* root) {
TreeNode* fr;
if(root == NULL){
return result;
}
que.push(root);
while(!que.empty()){
fr = que.front();
result.push_back(fr->val);
if(fr->left != NULL){
que.push(fr->left);
}
if(fr->right != NULL){
que.push(fr->right);
}
que.pop();
}
return result;
}
private:
vector<int> result;
queue<TreeNode*> que;
};剑指Offer（二十四）：二叉树中和为某一值的路径
题目
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
1、思路
深度优先搜索。使用前序遍历，使用两个全局变量result和tmp，result来存放最终结果，tmp用来存放临时结果。
每次遍历，我们先把root的值压入tmp，然后判断当前root是否同时满足：
- 与给定数值相减为0；
- 左子树为空；
- 右子树为空。
如果满足条件，就将tmp压入result中，否则，依次遍历左右子树。需要注意的是，遍历左右子树的时候，全局变量tmp是不清空的，直到到了根结点才请空tmp。
2、代码
C++：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<vector<int> > FindPath(TreeNode* root,int expectNumber){
if(root == NULL){
return result;
}
tmp.push_back(root->val);
if((expectNumber - root->val ) == 0 && root->left == NULL && root->right == NULL){
result.push_back(tmp);
}
//遍历左子树
FindPath(root->left, expectNumber - root->val);
//遍历右子树
FindPath(root->right, expectNumber - root->val);
tmp.pop_back();
return result;
}
private:
vector<vector<int> > result;
vector<int> tmp;
};剑指Offer（三十八）：二叉树的深度
题目
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
1、思路
这道题蛮简单的，求二叉树的深度。可以是递归的方法，属于DFS（深度优先搜索）；另一种方法是按照层次遍历，属于BFS（广度优先搜索）。
2、代码
C++：
DFS方法：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if(pRoot == NULL){
return 0;
}
int left = TreeDepth(pRoot->left);
int right = TreeDepth(pRoot->right);
return (left > right) ? (left + 1) : (right + 1);
}
};BFS方法：
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
int TreeDepth(TreeNode* pRoot)
{
if(pRoot == NULL){
return 0;
}
queue<TreeNode*> que;
int depth = 0;
que.push(pRoot);
while(!que.empty()){
int size = que.size();
depth++;
for(int i = 0; i < size; i++){
TreeNode* node = que.front();
que.pop();
if(node->left){
que.push(node->left);
}
if(node->right){
que.push(node->right);
}
}
}
return depth;
}
};
转自：https://blog.csdn.net/c406495762/article/details/79247243
868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
