二叉树问题（打印二叉树，二叉树子结构、镜像、遍历，二叉树满足的路径）

题目一：从上往下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

题目解析：这道题实质考查树的遍历算法，遍历通常有前序、中序、后序遍历，此题考查层次遍历。

1、我们需要借助队列，实现按层打印，首先将根节点放入队列中，并将根节点的值放入vector中；

2、判断根节点的左子树是否为空，不为空将该节点放入队列中；

3、判断根节点的右子树是否为空，不为空将该节点放入队列中；

循环读取队列中的节点，并对该节点做左右子树的判断，直至队列中不存在该节点；

二叉树的结构如下所示：

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) {
vector<int> printTreeNode;
//借用队列进行层次遍历
queue<TreeNode*> pTree;
if(root == NULL)  return printTreeNode;
else
{   pTree.push(root);
while(!pTree.empty())
{
TreeNode * proot = pTree.front();
printTreeNode.push_back(proot->val);
pTree.pop();
if(proot->left != NULL){pTree.push(proot->left);}
if(proot->right !=NULL){pTree.push(proot->right);}
}
}
return printTreeNode;
}
};

二叉树的前序、中序、后序遍历有递归和非递归两种形式

详解解析参考：http://www.cnblogs.com/SHERO-Vae/p/5800363.html

题目二：二叉树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）


如果A中有一部分子树的结构和B是一样的，因此B是A的子结构

找出B的根节点在A树中的位置，然后采用递归方法进行遍历，在面试的时候如果没有特殊的要求，树的遍历都可以采用递归的方式。

class Solution {
public:
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{  bool result = false;
if(pRoot1 != NULL && pRoot2 != NULL)
{
return DoesTree1HaveTree2(pRoot1,pRoot2) || HasSubtree(pRoot1->left,pRoot2) || HasSubtree(pRoot1->right,pRoot2);                }
return result;//如果有一个节点为空，则直接返回false
}
bool  DoesTree1HaveTree2(TreeNode* pRoot1,TreeNode* pRoot2)//定义一个函数进行两个树节点的匹配
{
//如果tree2遍历完，值都对应则说明含有此子树
if(pRoot2 == NULL){return true;}
//如果tree2遍历完，tree1已经结束，则说明不包含此子树
if(pRoot1 == NULL){return false;}
//如果值不同，则返回false
if(pRoot1->val != pRoot2->val){return false;}
//根节点匹配上，则分别进行左右子树的匹配
return DoesTree1HaveTree2(pRoot1->left,pRoot2->left) && DoesTree1HaveTree2(pRoot1->right,pRoot2->right);
//左右子树必须同时匹配
}
};

题目三：二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像

二叉树的镜像定义：源二叉树
8
/  \
6   10
/ \  / \
5  7 9 11
镜像二叉树
8
/  \
10   6
/ \  / \
11 9 7  5

镜像就是将二叉树的左右子树进行交换，可以采用递归和非递归的方法进行交换

递归方法如下所示：

class Solution {
public:
void Mirror(TreeNode *pRoot) {
//镜像就是将左右子树进行交换
if(pRoot == NULL) return;
if(pRoot)
{
TreeNode * temp = pRoot->left;
pRoot->left = pRoot->right;
pRoot->right = temp;
Mirror(pRoot->left);
Mirror(pRoot->right);
}
}
};

非递归方法如下所示：

非递归的方法，左右子树都要事先和根节点一样的其左右子树的交换，如果左右都在一次循环中赋值给根节点，

肯定会有一个被覆盖可以采用stack,queue,vector等容器盛放这两个节点，然后实现循环交换

本题采用队列的方法实现非递归

class Solution {
public:
void Mirror(TreeNode *pRoot) {
if(pRoot == NULL) return;
queue<TreeNode *> treeQueue;
treeQueue.push(pRoot);
while(!treeQueue.empty())
{
TreeNode *root = treeQueue.front();
TreeNode *temp = root->left;
root->left = root->right;
root->right = temp;
if(root->left)
{
treeQueue.push(root->left);
}
if(root->right)
{
treeQueue.push(root->right);
}
treeQueue.pop();
}
}
};

题目四：二叉搜索树的后序遍历

题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。

假设输入的数组的任意两个数字都互不相同

题目解析：二叉搜索树节点值的规律是： 左  < 根 < 右

                  后序遍历的序列，最后一个值为根节点，并且小于根节点的值属于左子树，大于根节点的值属于右子树

递归方法：此题的递归方法比较好理解

1、首先将整个二叉树的根节点找到，把左子树放入一个数组中，右子树放入一个数组中；

2、然后左右子树的数组递归调用此方法；

3、当两个子树调用的结果都为真时，则结果为真；

代码如下：

class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
//递归方法
if(sequence.size() == 0){return false;}
int length = sequence.size();
int root = sequence[length-1];
vector<int> leftTree;
vector<int> rightTree;
int i = 0;
for(i;i < length-1;i++)//排除根节点，所以上限要小于length-1
{
if(sequence[i] > root)
{
break;//当节点值大于根节点时，左子树已结束，退出循环
}
leftTree.push_back(sequence[i]);
}
for(int j = i; j < length-1; j++) //排除根节点，所以上限要小于length-1
{
if(sequence[j] < root)
{
return false;//当右子树出现小于根节点的值时，则出现错误，则不是后序遍历的结果
}
rightTree.push_back(sequence[j]);
}
bool left = true, right = true;
if(leftTree.size() > 0) {left = VerifySquenceOfBST(leftTree);} //判断子树的值是否为空，为空则不用再继续调用
if(rightTree.size() > 0){right = VerifySquenceOfBST(rightTree);}
return (left && right);
}
};

非递归的方法很简单也很好理解，因为搜索二叉树后序遍历是有规律的，前面一部分小于最后一个值，后面一部分大于最后一个值，只要不出现后面一部分小于的情况，就说明这个数组是某搜索二叉树的遍历了，和上面递归的方法使相同的，只是没有按规则划分左子树和右子树；而是每一个节点都是根节点，他的左边都是左子树，右边都是右子树。如果右子树出现比根节点小的值就是不对的。

代码如下所示：

class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
int size = sequence.size();
if(size == 0) return false;
int i = 0;
while(--size)
{
while(sequence[i] < sequence[size]){i++;}
while(sequence[i] > sequence[size]){i++;}
if(i < size)  {return false;}
i = 0;
}
return true;
}
};

题目五：二叉树和为某一树的路径

题目描述：输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。

路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

本题考查的是深度优先遍历，可以采用递归和非递归的形式

非递归的代码如下所示：

class Solution {
public:
vector<vector<int>> pathNum;
vector<int> pathValue;
vector<vector<int>> FindPath(TreeNode* root,int expectNumber) {
if(root == NULL) return pathNum;
//非递归方法，采用先序遍历的非递归形式
stack<TreeNode*> stackTree;
TreeNode* cur = root;
TreeNode* last = NULL;
int sum = 0;
while(cur || !stackTree.empty())
{  while(cur)//深度优先，先遍历左孩子
{  pathValue.push_back(cur->val);
sum = sum + pathValue.back();
stackTree.push(cur);
if(sum == expectNumber && cur->right == NULL && cur->left == NULL)
{
pathNum.push_back(pathValue);
}
cur = cur->left;
}
if(cur == NULL )
{
TreeNode* temp = stackTree.top();
//这个条件判断是最主要的问题所在，在转左子树之前要判断此节点是否和上一节点相同
if(temp->right != NULL && temp->right != last)
{
cur = temp->right;
}
else if(!pathValue.empty())
{
last = temp;
stackTree.pop();
sum = sum - pathValue.back();
pathValue.pop_back();
}
}
}
return pathNum;
}
};

递归的代码如下所示：

class Solution {
public:
vector<vector<int>> pathNum;
vector<int> pathValue;
vector<vector<int>> FindPath(TreeNode* root,int expectNumber) {
if(root == NULL) return pathNum;
//递归方法
if(root)
{
dfs(root,expectNumber);
a94a

}
return pathNum;
}
//深度优先算法
void dfs(TreeNode * cur,int sum)
{
pathValue.push_back(cur->val);
if(sum - cur->val == 0 && cur->left == NULL && cur->right == NULL)
{
pathNum.push_back(pathValue);
}else{
if(cur->left) { dfs(cur->left,sum - cur->val);}
if(cur->right){ dfs(cur->right,sum - cur->val);}
}
pathValue.pop_back();
}
};