每日一题（11）

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

解析：
                  1
                /   \
               2     3
              /     /  \
             4     5    6

  二叉树的深度，即为二叉树的高度，如果规定根节点所处层在第一层，深度也可看成二叉树的最大层数
  直接求二叉树的高度，不太好求，但是如果能知道子树的高度，那取其最大者加1就是二叉树的高度
  因此，此题可以先使用递归方式求出二叉树子树的高度，然后再求二叉树高度。
  方法：
     1. 如果树为空，返回0
     2. 递归求解左子树高度
        递归求解右子树高度
     3. 返回左右子树中较大者

/*
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;
        size_t leftDepth=TreeDepth(pRoot->left);
        size_t rightDepth=TreeDepth(pRoot->right);
        return leftDepth>rightDepth?leftDepth+1:rightDepth+1;
    }
};

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

二叉树的镜像定义：源二叉树 

  ​         8
          /  \
         6    10
       /   \ /   \
      5    7 9   11

  镜像二叉树
         8
      /    \
     10     6
    /  \   / \
   11   9 7   5

方法一：采用递归实现(前序遍历思想)
镜像的本质是将二叉树中每个结点的左右孩子进行交换。
思路：
1. 可以先交换根节点的左右子树，即将根节点先镜像成功；
2. 镜像根节点的左子树(因为左子树也是树，镜像的方式与根节点类似，递归)
3. 镜像根节点的右子树

递归方式
优点：代码简介，但是想清楚过程却不是很好理解
缺点：如果二叉树的高度比较高，可能会造成栈溢出

/*
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){
            swap(pRoot->left,pRoot->right);
            Mirror(pRoot->left);
            Mirror(pRoot->right);
        }
    }
};

方法二：采用循环
思路：按照层序遍历规则依次镜像(交换)每个结点

/*
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(NULL == pRoot)
            return;

        queue<TreeNode*> q;
        q.push(pRoot);

        TreeNode* pCur;
        while(!q.empty())
        {
            pCur = q.front();
            swap(pCur->left, pCur->right);

            if(pCur->left)
                q.push(pCur->left);

            if(pCur->right)
                q.push(pCur->right);

            q.pop();
        }
    }
};