根据中序和先序重建二叉树+二叉树的镜像+二叉树的深度+判断后序序列+判断子树

题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路：递归。首先先序的第一个元素一定是根节点，然后在中序中以根节点为分界，左边的为左子树的所有节点，右边的为右子树的所有节点，相应地也将先序划分为左右子树，这样就分别得到了左右子树的先序和中序，递归地继续调用该函数即可

/** * 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||vin.size()==0) return NULL;        TreeNode* root=new TreeNode(pre[0]);//先序的第一个节点为根节点        int rootIndex=0;        for(int i=0;i<vin.size();i++){            if (vin[i]==pre[0])                rootIndex=i;//找到根节点在中序中的位置        }        vector<int> temppre1;        vector<int> tempvin1;        for(int i=0;i<rootIndex;i++){            tempvin1.push_back(vin[i]);            temppre1.push_back(pre[i+1]);//得到左子树的先序和中序        }        vector<int> temppre2;        vector<int> tempvin2;        for(int i=rootIndex+1;i<vin.size();i++){            tempvin2.push_back(vin[i]);            temppre2.push_back(pre[i]);//得到右子树的先序和中序        }        root->left=reConstructBinaryTree(temppre1,tempvin1);//左子树递归，结果为根节点的左节点        root->right=reConstructBinaryTree(temppre2,tempvin2);  //右子树递归，结果为根节点的右节点         return root;    }   };

题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

class Solution {public:    void Mirror(TreeNode *pRoot) {        if(pRoot==NULL||(pRoot->left==NULL&&pRoot->right==NULL)) return;        TreeNode* left=pRoot->left;        TreeNode* right=pRoot->right;        pRoot->left=right;        pRoot->right=left;//交换左右子树        Mirror(pRoot->left);//递归左子树        Mirror(pRoot->right); //递归右子树       }};

题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

class Solution {public:    int TreeDepth(TreeNode* pRoot)    {        if (pRoot==NULL) return 0;        if(pRoot->left==NULL&&pRoot->right==NULL) return 1;        int l=0;        int r=0;        if (pRoot->left!=NULL){            l=TreeDepth(pRoot->left);//左子树的深度        }        if(pRoot->right!=NULL){            r=TreeDepth(pRoot->right);//右子树的深度        }        return max(l,r)+1; //树的深度为左右子树的最大值+1    }};

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路：分别求出左右子树的深度，判断深度之差绝对值小于2，且左右子树为平衡二叉树

class Solution {public:    int TreeDepth(TreeNode*pRoot){        if (pRoot==NULL) return 0;        if(pRoot->left==NULL&&pRoot->right==NULL) return 1;        int l=0;        int r=0;        if (pRoot->left!=NULL){            l=TreeDepth(pRoot->left);//左子树的深度        }        if(pRoot->right!=NULL){            r=TreeDepth(pRoot->right);//右子树的深度        }        return max(l,r)+1; //树的深度为左右子树的最大值+1    }    bool IsBalanced_Solution(TreeNode* pRoot) {        if(pRoot==NULL||(pRoot->left==NULL&&pRoot->right==NULL)) return true;        int l=0;        int r=0;        if(pRoot->left!=NULL) l=TreeDepth(pRoot->left);        if(pRoot->right!=NULL) r=TreeDepth(pRoot->right);        if(IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right)&&abs(l-r)<2) return true;        return false;    }};

题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

class Solution {public:    bool VerifySquenceOfBST(vector<int> sequence) {        int l=sequence.size();        if(l==0) return false;        if(l<=2) return true;        int num=sequence[l-1]; //最后一个元素num作为分界线        int i=0;        int j=l-2; //要先将最后一个元素排除        while(i<l&&sequence[i]<num) i++; //找到比num小的连续序列        while(j>=0&&sequence[j]>num) j--;//找到比num大的连续序列        vector<int> left;        vector<int> right;        for(int k=0;k<i;k++) left.push_back(sequence[k]);        for(int k=j+1;k<l-1;k++) right.push_back(sequence[k]); //注意此处为k<l-1                return ((left.empty()&&VerifySquenceOfBST(right)&&i==j+1)||(right.empty()&&VerifySquenceOfBST(left)&&i==j+1)||(i==j+1&&VerifySquenceOfBST(left)&&VerifySquenceOfBST(right))); //首先根据最后一个元素可以将vector完全分为两部分（即i=j+1），之后有三种情况：（1）左边为空，右边为后序序列；（2）右边为空，左边为后序序列；（3）左右均为后序序列    }};

题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：使用递归算法，首先在1树中找与2树的根节点值相同的节点，然后判断以该节点为根的子树是否与2树相同。

class Solution {public:    bool IsSubTree(TreeNode* pRoot1, TreeNode* pRoot2){        if(pRoot2==NULL) return true;        if(pRoot1==NULL) return false;        if(pRoot1->val!=pRoot2->val) return false;        return (pRoot1->val==pRoot2->val&&IsSubTree(pRoot1->left,pRoot2->left)&&IsSubTree(pRoot1->right,pRoot2->right));//节点值相等且左右子树都相同    }    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)    {        bool result=false;        if(pRoot2==NULL||pRoot1==NULL) return false;        if(pRoot1->val==pRoot2->val){            result=IsSubTree(pRoot1,pRoot2);//如果节点的值相等，就判断是否是相同树        }        if(!result&&pRoot1->left!=NULL){            return HasSubtree(pRoot1->left,pRoot2);//如果节点值不相等，就判断左子树中有没有pRoot2的子结构        }        if(!result&&pRoot1->right!=NULL){            return HasSubtree(pRoot1->right,pRoot2);        }        return result;    }};