二叉树的深度(最大最小)

package sy1;


import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

public class test {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(3);
        TreeNode node1 = new TreeNode(9);
        TreeNode node2 = new TreeNode(20);
        TreeNode node3 = new TreeNode(15);
        TreeNode node4 = new TreeNode(7);
        root.left = node1;
        root.right = node2;
        node2.left = node3;
        node2.right = node4;
        C c = new C();
        c.order(root);
        
    }
}

class C {
    public void order(TreeNode node) {
        if (node == null) {
            return;
        }
        order(node.left);
        System.out.print(node.val + " ");
        order(node.right);
    }

    /**
     * 最大深度(深度优先)
     *
     * @param node
     * @return
     */
    public int maxDepth3(TreeNode node) {
        if (node == null) {
            return 0;
        } else {
            int leftHeight = maxDepth3(node.left);
            int rightHeight = maxDepth3(node.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }


    /**
     * 最大深度广度
     *
     * @param root
     * @return
     */
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int ans = 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--;
            }
            ans++;
        }
        return ans;
    }

    /**
     * 最小深度深度优先
     *
     * @param root
     * @return
     */
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        if (root.left == null && root.right == null) {
            return 1;
        }

        int min_depth = Integer.MAX_VALUE;
        if (root.left != null) {
            min_depth = Math.min(minDepth(root.left), min_depth);
        }
        if (root.right != null) {
            min_depth = Math.min(minDepth(root.right), min_depth);
        }

        return min_depth + 1;
    }

    /**
     * 广度优先遍历
     *
     * @param root
     * @return 最小深度
     */
    public static int minDepth2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        Deque<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        int level = 1;
        while (!deque.isEmpty()) {
            int size = deque.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = deque.poll();
                //找到叶子节点最小
                if (cur.right == null && cur.left == null) {
                    return level;
                }
                if (cur.left != null) {
                    deque.offer(cur.left);
                }
                if (cur.right != null) {
                    deque.offer(cur.right);
                }
            }
            level++;
        }
        return level;
    }

}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}