一、对称二叉树

        给定一颗二叉树，检查他是否对称

        思路：使用递归处理（递归的比较左子树的左孩子和右子树的右孩子）

public bool isSymmetric(TreeNHode root)
{
    if(root == nuill)
        return ture;
    return deepCheck(root.left,root.right);//递归比较
}

bool deepCheck(TreeNode left,TreenNode right)
{
    if(left == null && right == null)
        return true;
    if(left == null || right == null)
        return false;
    if(left.val != right.val)
        return false;

    //进行递归检查
    return deepCheck(left.left,right.right) && deepCheck(left.right,right.left);
}

        思路2：   ①将根节点的左孩子和右孩子全部入队，然后出队

                        ②出队后将左孩子的左子树和右孩子的右子树/左孩子的右子树和右孩子的左子树放入队列

                        ③再次出队，同时按照方法②的顺序将下一层入队

public bool isSymmetric(TreeNode root)
{
    Queue<TreeNode> q = new LinkedList<TreeNode>();
    TreeNode u = root.left;
    TreeNode v = root.right;
    if(root == null || u == null || v == null)
        return false;
    q.offer(u);
    q.offer(v);
    
    while(!q.isEmpty())
    {
        u = q.poll();
        v = q.poll();
        if(u == null && v == null)
            contiune;
        if((u == null || v ==null) || (u.val != v.val))

            return false;
        
        q.offer(u.left);
        q.offer(v.right);

        q.offer(u.right);
        q.offer(v.left);
    }
    return true;
}

二、二叉树的最大深度

        思路：遍历根结点的左孩子和右孩子，取出最大高度+1即可

public int MaxDepth(TreeNode root)
{
    if(root == null)
        return 0;
    else
        return Math.max( maxDepth(root.left) , maxDepth(root.right) )+1
}

        思路2：使用队列实现（分层推入队列，高度+1）

public int maxDepth(TreeNode root)
{
    if(root == null)
        return 0;
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);
    int depth = 0;
    while(!queue.isEmpty())
    {
        int size = queue.size();//记录本层级的节点是否完成处理
        while(size > 0)
        {
            TreeNode node = queue.poll();
            if(node.left != null)
                queue.offer(node.left);
            if(node.right != null)
                queue.offer(node.right);
            size--;
        }
        depth++;
    }
    return depth;
}

三、平衡二叉树

        判断一颗二叉树是否是高度平衡的二叉树（每个结点的左右子树的高度差值不超过1）

        思路：从定义来看，一颗二叉树是平衡二叉树的条件是其子树都是平衡二叉树。可以使用递归的方式来判定其是否平衡。从最底层的子树开始判断，逐层向上直到根为止。

public bool isBalanced(TreeNode root)
{
    if(root == null)
        return true;
    return helper(root) != -1;
}

int helper(TreeNode root)
{
    if(root == null)
        return 0;
    int left = helper(root.left);
    int right = helper(root.right);

    if(left == -1 || right == -1 || Math.abs(left - right) >－１)
        return -1;
    return Math.max(left,right)+1;
}

 四、反转二叉树

         思路：使用递归将左右子树进行调转

public TreeNode invertTree(TreeNoderoot)
{
    if(root == null)
        return null;
    invertTree(root.left);
    invertTree(root.right);

    TreeNode temp = root.left;
    root.left = root.right;
    root.right = temp;
    return root;
}