翻转二叉树，最大深度，最小深度

class Solution {
    public void Swap(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }

    public TreeNode invertTree(TreeNode root) {
        //迭代法 遍历到每一个节点然后交换他的左右孩子
        if(root == null) return root;
        Stack<TreeNode> stk = new Stack<>();
        stk.push(root);

        while(!stk.isEmpty()){
            TreeNode tempnode = stk.peek();
            stk.pop();
            //对于当前节点交换左右孩子
            Swap(tempnode);
            if(tempnode.right != null) stk.push(root.right);
            if(tempnode.left != null) stk.push(root.left);
        }
        return root;
    }
}

class Solution {
    public int maxDepth(TreeNode root) {
        //层次遍历求二叉树的深度
        if(root == null) return 0;
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        int depth = 0;//每取出一层则depth加1
        while(!que.isEmpty()){
            int len = que.size();
            depth++;
            while(len-- >0){
                TreeNode tempNode = que.poll();
                if(tempNode.left != null) que.offer(tempNode.left);
                if(tempNode.right != null) que.offer(tempNode.right);
            }
        }
        return depth;

    }
}
class Solution {
    public int minDepth(TreeNode root) {
        //使用递归,由于我们算的是到叶子节点的最低高度
        //对于每一个节点我们的最低高度是从此节点到离它最近的叶子节点
        if(root == null) return 0;
        int leftheight = minDepth(root.left);
        int rightheight = minDepth(root.right);
        if(root.left == null && root.right != null) return 1  + rightheight;
        if(root.left != null && root.right == null) return 1  + leftheight;
        return Math.min(leftheight,rightheight) + 1;
    }
}

加油，至少先把算法和锻炼身体给加强起来