面试可能会问到: 二叉树递归~~~理解递归的本质！！

思路：
这道题是很经典的递归题，返回二叉树的镜像:
既然是递归，我们就要明确递归的意义：
假设我们对：TreeNode* mirrorTree(TreeNode* root) 这个函数做递归，什么意思！重复调用，那这个函数是什么功能　：这个函数实现了对输入root作为根节点的二叉树进行镜像翻转！然后看返回，返回当前根节点！！
好，我们递归首先对根节点记录左右节点，然后翻转，然后左右节点进去之后继续调用，以左节点为根节点反转，以右节点为根节点反转
注意到 return nullptr是针对最后一层的，而return root是针对第一层和中间层的，当然nullptr也针对初始是nullptr了，那就是本身就是最后一层啦哈哈

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode* left = mirrorTree(root->left);
        TreeNode* right = mirrorTree(root->right);
        root->left = right;
        root->right = left;
        return root;
    }
};

或者

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        // 考虑为空情况
        if (root == nullptr)
        {
            return nullptr;
        }
        // left 和 right 反序, 临时保存left结点
        TreeNode* temp = root->left;
        root->left = mirrorTree(root->right);
        root->right = mirrorTree(temp); 
        return root;
    }
};

或者：

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        dfs(root);
        return root;
    }
    void dfs(TreeNode* root){
        if(root==nullptr)
            return;
        TreeNode* temp=root->left;
        root->left=root->right;
        root->right=temp;
        dfs(root->left);
        dfs(root->right);
    }
};

——————————————————————————————————————————————————————
2.对称的二叉树：判断输入的二叉树是不是对称的 也是递归！！！！！一个root不好判断，那我进左右2root

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return root==nullptr ? true: recur(root->left,root->right);
    }
    bool recur(TreeNode* left,TreeNode* right){
        if(left==nullptr && right==nullptr) return true;
        if(left==nullptr || right==nullptr || left->val!=right->val) return false;
        return recur(left->left,right->right) && recur(left->right,right->left); 
    }
};

---

剑指 Offer 33. 二叉搜索树的后序遍历序列

思路：
　　递归地判断左右子树是不是符合条件！！！！！！！！！！！说白了是节点判断，判断这个根节点的左右子树整体情况，然后再细分下去，如果判断的是空树或者单树就说明结束了

class Solution {
public:
    bool verifyPostorder(vector<int>& postorder) {
        return recur(postorder,0,postorder.size()-1);
    }
    bool recur(vector<int>& postorder,int i,int j){
        if(i>=j) return true;
        int p=i;
        while(postorder[p]<postorder[j]) p++;
        int m=p;
        while(postorder[p]>postorder[j]) p++;
        return p==j && recur(postorder,i,p-1)&&recur(postorder,m,j-1);
    }
};