add 872

fishercoder1534 · fishercoder1534 · commit 046def62e404 · 2018-12-31T21:10:55.000-08:00
diff --git a/README.md b/README.md
@@ -42,6 +42,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) | O(n) | O(1) | |Easy|
 |884|[Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_884.java) | O(n) | O(k) | |Easy|
 |876|[Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_876.java) | O(n) | O(1) | |Easy|
+|872|[Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_872.java) | O(n) | O(h) | |Easy| DFS, recursion
 |868|[Binary Gap](https://leetcode.com/problems/binary-gap/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_868.java) | O(n) | O(n) | |Easy|
 |867|[Transpose Matrix](https://leetcode.com/problems/transpose-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_867.java) | O(r*c) | O(r*c) | |Easy|
 |859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_859.java) | O(n) | O(n) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_872.java b/src/main/java/com/fishercoder/solutions/_872.java
@@ -0,0 +1,52 @@
+package com.fishercoder.solutions;
+
+import com.fishercoder.common.classes.TreeNode;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 872. Leaf-Similar Trees
+ *
+ * Consider all the leaves of a binary tree.  From left to right order, the values of those leaves form a leaf value sequence.
+ *
+ *          3
+ *         / \
+ *        5   1
+ *       / \ / \
+ *      6  2 9 8
+ *        / \
+ *       7  4
+ *
+ * For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8).
+ *
+ * Two binary trees are considered leaf-similar if their leaf value sequence is the same.
+ *
+ * Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar.
+ *
+ * Note:
+ *
+ * Both of the given trees will have between 1 and 100 nodes.
+ */
+public class _872 {
+  public static class Solution1 {
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+      List<Integer> leaves1 = new ArrayList<>();
+      List<Integer> leaves2 = new ArrayList<>();
+      preorder(root1, leaves1);
+      preorder(root2, leaves2);
+      return leaves1.equals(leaves2);
+    }
+
+    private void preorder(TreeNode root,
+        List<Integer> leaves) {
+      if (root == null) {
+        return;
+      }
+      if (root.left == null && root.right == null) {
+        leaves.add(root.val);
+      }
+      preorder(root.left, leaves);
+      preorder(root.right, leaves);
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_872Test.java b/src/test/java/com/fishercoder/_872Test.java
@@ -0,0 +1,41 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.TreeNode;
+import com.fishercoder.common.utils.TreeUtils;
+import com.fishercoder.solutions._872;
+import java.util.Arrays;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _872Test {
+  private static _872.Solution1 solution1;
+  private static TreeNode root1;
+  private static TreeNode root2;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _872.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    root1 = TreeUtils.constructBinaryTree(Arrays.asList(3, 5, 6, 2, 7, 4, 1, 9, 8));
+    root2 = TreeUtils.constructBinaryTree(Arrays.asList(3, 5, 6, 2, 7, 4, 1, 9, 8));
+    TreeUtils.printBinaryTree(root1);
+    TreeUtils.printBinaryTree(root2);
+    assertEquals(true, solution1.leafSimilar(root1, root2));
+  }
+
+  @Test
+  public void test2() {
+    root1 =
+        TreeUtils.constructBinaryTree(Arrays.asList(18, 35, 22, null, 103, 43, 101, 58, null, 97));
+    TreeUtils.printBinaryTree(root1);
+    root2 =
+        TreeUtils.constructBinaryTree(Arrays.asList(94, 102, 17, 122, null, null, 54, 58, 101, 97));
+    TreeUtils.printBinaryTree(root2);
+    assertEquals(false, solution1.leafSimilar(root1, root2));
+  }
+}
