最大深度、平衡二叉树、镜像二叉树

Author: FantasyLWX

README.md

@@ -77,5 +77,10 @@
 ### 二叉树
 
 - [二叉树的深度优先遍历和广度优先遍历][traversal-binary-search-tree]
+- [二叉树的最大深度][max-depth]
+- [判断是否是平衡二叉树][judge-binary-search-tree]
+- [判断是否是镜像二叉树][judge-binary-search-tree]
 
 [traversal-binary-search-tree]: ./src/com/fantasy/algorithm/tree/TraversalBinarySearchTree.java
+[max-depth]: ./src/com/fantasy/algorithm/tree/MaxDepth.java
+[judge-binary-search-tree]: ./src/com/fantasy/algorithm/tree/JudgeBinarySearchTree.java

src/com/fantasy/algorithm/tree/JudgeBinarySearchTree.java

@@ -0,0 +1,78 @@
+package com.fantasy.algorithm.tree;
+
+import com.fantasy.datastructure.tree.TreeNode;
+
+/**
+ * 判断二叉树的一些特性的相关算法
+ *
+ * <pre>
+ *     author  : Fantasy
+ *     version : 1.0, 2020-08-18
+ *     since   : 1.0, 2020-08-18
+ * </pre>
+ */
+public class JudgeBinarySearchTree {
+
+    public static void main(String[] args) {
+        TreeNode root = new TreeNode(1);
+        TreeNode node2 = new TreeNode(2);
+        TreeNode node3 = new TreeNode(2);
+        TreeNode node4 = new TreeNode(3);
+        TreeNode node5 = new TreeNode(4);
+        TreeNode node6 = new TreeNode(4);
+        TreeNode node7 = new TreeNode(3);
+        root.left = node2;
+        root.right = node3;
+        node2.left = node4;
+        node2.right = node5;
+        node3.left = node6;
+        node3.right = node7;
+
+        System.out.println("isBalanced : " + isBalanced(root));
+        System.out.println("isSymmetric : " + isSymmetric(root));
+    }
+
+    private static boolean isBalanced = true;
+
+    /**
+     * 是否是平衡二叉树
+     */
+    public static boolean isBalanced(TreeNode root) {
+        isBalanced = true;
+        getDepth(root);
+        return isBalanced;
+    }
+
+    public static int getDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int left = getDepth(root.left);
+        int right = getDepth(root.right);
+        if (Math.abs(left - right) > 1) {
+            isBalanced = false;
+        }
+        return left > right ? left + 1 : right + 1;
+    }
+
+    /**
+     * 是否是镜像二叉树
+     */
+    public static boolean isSymmetric(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+        return isSym(root.left, root.right);
+    }
+
+    public static boolean isSym(TreeNode r1, TreeNode r2) {
+        if (r1 == null && r2 == null) {
+            return true;
+        }
+        if (r1 == null || r2 == null) {
+            return false;
+        }
+        return r1.value == r2.value && isSym(r1.left, r2.right) && isSym(r1.right, r2.left);
+    }
+
+}

src/com/fantasy/algorithm/tree/MaxDepth.java

@@ -0,0 +1,79 @@
+package com.fantasy.algorithm.tree;
+
+import java.util.LinkedList;
+
+import com.fantasy.datastructure.tree.BinarySearchTree;
+import com.fantasy.datastructure.tree.TreeNode;
+
+/**
+ * 二叉树的最大深度
+ *
+ * <pre>
+ *     author  : Fantasy
+ *     version : 1.0, 2020-08-18
+ *     since   : 1.0, 2020-08-18
+ * </pre>
+ */
+public class MaxDepth {
+
+    public static void main(String[] args) {
+        //      3
+        //    /   \
+        //   2     5
+        //  /     / \
+        // 1     4   6
+        BinarySearchTree tree = new BinarySearchTree();
+        tree.insert(3);
+        tree.insert(2);
+        tree.insert(5);
+        tree.insert(1);
+        tree.insert(4);
+        tree.insert(6);
+
+        System.out.println("max depth : " + getMaxDepth(tree.getRoot()));
+        System.out.println("max depth2 : " + getMaxDepth2(tree.getRoot()));
+    }
+
+    public static int getMaxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        int leftDepth = getMaxDepth(root.left);
+        int rightDepth = getMaxDepth(root.right);
+
+        return leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);
+    }
+
+    public static int getMaxDepth2(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        TreeNode current = null;
+        LinkedList<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int cur, last;
+        int level = 0;
+
+        while (!queue.isEmpty()) {
+            cur = 0; // 记录本层已经遍历的结点个数
+            last = queue.size(); // 当遍历完当前层以后，队列里元素全是下一层的元素，队列的长度是这一层的结点的个数
+            while (cur < last) { // 当还没有遍历到本层最后一个结点时，继续循环
+                current = queue.poll(); // 出队一个元素
+                cur++;
+                // 把当前结点的左右结点入队（如果存在的话）
+                if (current.left != null) {
+                    queue.offer(current.left);
+                }
+                if (current.right != null) {
+                    queue.offer(current.right);
+                }
+            }
+            level++; // 每遍历完一层level+1
+        }
+
+        return level;
+    }
+
+}