feat: add 100

Author: Blankj

note/088/README.md

@@ -12,7 +12,7 @@ You may assume that *nums1* has enough space (size that is greater or equal to *
 
 ## 思路
 
-题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存覆盖的元素，所以我们选择逆序，这样利用`nums1`自身空间足矣，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
+题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用`nums1`自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
 
 ``` java
 public class Solution {

note/100/README.md

@@ -0,0 +1,37 @@
+# [Merge Sorted Array][title]
+
+## Description
+
+Given two sorted integer arrays *nums1* and *nums2*, merge *nums2* into *nums1* as one sorted array.
+
+**Note:**
+You may assume that *nums1* has enough space (size that is greater or equal to *m* + *n*) to hold additional elements from *nums2*. The number of elements initialized in *nums1* and *nums2* are *m* and *n* respectively.
+
+**Tags:** Array, Two Pointers
+
+
+## 思路
+
+题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用`nums1`自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
+
+``` java
+public class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        int p = m-- + n-- - 1;
+        while (m >= 0 && n >= 0)
+            nums1[p--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
+        while (n >= 0)
+            nums1[p--] = nums2[n--];
+    }
+}
+```
+
+
+## 结语
+
+如果你同我一样热爱数据结构、算法、LeetCode，可以关注我GitHub上的LeetCode题解：[awesome-java-leetcode][ajl]
+
+
+
+[title]: https://leetcode.com/problems/merge-sorted-array
+[ajl]: https://github.com/Blankj/awesome-java-leetcode

project/leetcode/.idea/workspace.xml

@@ -31,7 +31,6 @@ public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
 
     public static void main(String[] args) {
         Solution solution = new Solution();
-        ;
         ListNode listNode00 = new ListNode(1);
         ListNode listNode01 = new ListNode(3);
         ListNode listNode02 = new ListNode(5);
@@ -52,10 +51,10 @@ public static void main(String[] args) {
         listNode12.next = listNode13;
         listNode13.next = listNode14;
         listNode14.next = null;
-        ListNode listNode0 = ListNode.createTestData(new int[]{1, 3, 5, 7, 9});
-        ListNode listNode1 = ListNode.createTestData(new int[]{2, 4, 6, 8, 10});
-        System.out.println(listNode0.toString());
-        System.out.println(listNode1.toString());
-        System.out.println(solution.mergeTwoLists(listNode0, listNode1).toString());
+        ListNode listNode0 = ListNode.createTestData("[1,3,5,7,9]");
+        ListNode listNode1 = ListNode.createTestData("[2,4,6,8,10]");
+        ListNode.print(listNode0);
+        ListNode.print(listNode1);
+        ListNode.print(solution.mergeTwoLists(listNode0, listNode1));
     }
 }

project/leetcode/out/production/leetcode/com/blankj/easy/_021/Solution.class

@@ -44,7 +44,7 @@ public String addBinary(String a, String b) {
 //            sb.insert(0, (char) (carry % 2 + '0'));
 //            carry >>= 1;
 //        }
-//        return sb.toString();
+//        return sb.print();
 //    }
 
     public static void main(String[] args) {

project/leetcode/out/production/leetcode/com/blankj/easy/_083/Solution.class

@@ -27,7 +27,7 @@ public ListNode deleteDuplicates(ListNode head) {
 
     public static void main(String[] args) {
         Solution solution = new Solution();
-        System.out.println(solution.deleteDuplicates(ListNode.createTestData(new int[]{1, 1, 2})));
-        System.out.println(solution.deleteDuplicates(ListNode.createTestData(new int[]{1, 1, 2, 3, 3})));
+        ListNode.print(solution.deleteDuplicates(ListNode.createTestData("[1,1,2]")));
+        ListNode.print(solution.deleteDuplicates(ListNode.createTestData("[1,1,2,3,3]")));
     }
 }

project/leetcode/out/production/leetcode/com/blankj/easy/_088/Solution.class

@@ -0,0 +1,25 @@
+package com.blankj.easy._100;
+
+
+import com.blankj.structure.TreeNode;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/06/05
+ *     desc  :
+ * </pre>
+ */
+
+public class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        return false;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        TreeNode.print(TreeNode.createTestData("[1,2,2,null,3,null,3]"));
+        System.out.println();
+    }
+}

project/leetcode/out/production/leetcode/com/blankj/easy/_100/Solution.class

@@ -17,26 +17,34 @@ public ListNode(int x) {
         val = x;
     }
 
-    @Override
-    public String toString() {
-        String str = "[" + String.valueOf(val);
-        ListNode p = next;
-        while (p != null) {
-            str += ", " + String.valueOf(p.val);
-            p = p.next;
-        }
-        return str + "]";
-    }
-
-    public static ListNode createTestData(int[] data) {
-        int len =  len = data.length;
-        if (len == 0) return null;
+    /**
+     * 创建测试数据
+     *
+     * @param data [XX,XX,XX]
+     * @return {@link ListNode}
+     */
+    public static ListNode createTestData(String data) {
+        if (data.equals("[]")) return null;
+        data = data.substring(1, data.length() - 1);
+        String[] split = data.split(",");
+        int len = split.length;
         ListNode[] listNode = new ListNode[len + 1];
-        listNode[0] = new ListNode(data[0]);
+        listNode[0] = new ListNode(Integer.valueOf(split[0]));
         for (int i = 1; i < len; i++) {
-            listNode[i] = new ListNode(data[i]);
+            listNode[i] = new ListNode(Integer.valueOf(split[i]));
             listNode[i - 1].next = listNode[i];
         }
         return listNode[0];
     }
+
+    public static void print(ListNode listNode) {
+        if (listNode == null) System.out.println("null");
+        StringBuilder str = new StringBuilder("[" + String.valueOf(listNode.val));
+        ListNode p = listNode.next;
+        while (p != null) {
+            str.append(",").append(String.valueOf(p.val));
+            p = p.next;
+        }
+        System.out.println(str.append("]"));
+    }
 }

project/leetcode/out/production/leetcode/com/blankj/structure/ListNode.class

@@ -0,0 +1,92 @@
+package com.blankj.structure;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2017/06/05
+ *     desc  :
+ * </pre>
+ */
+public class TreeNode {
+
+    public int      val;
+    public TreeNode left;
+    public TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+
+    /**
+     * 创建测试数据
+     *
+     * @param data [XX,XX,null,xx]
+     * @return {@link TreeNode}
+     */
+    public static TreeNode createTestData(String data) {
+        if (data.equals("[]")) return null;
+        data = data.substring(1, data.length() - 1);
+        String[] split = data.split(",");
+        int len = len = split.length;
+        TreeNode[] treeNodes = new TreeNode[len];
+        data = data.substring(1, data.length() - 1);
+        for (int i = 0; i < len; i++) {
+            if (!split[i].equals("null")) {
+                treeNodes[i] = new TreeNode(Integer.valueOf(split[i]));
+            }
+        }
+        for (int i = 0; i < len; i++) {
+            if (treeNodes[i] != null) {
+                int leftIndex = i * 2 + 1;
+                if (leftIndex < len) {
+                    treeNodes[i].left = treeNodes[leftIndex];
+                }
+                int rightIndex = leftIndex + 1;
+                if (rightIndex < len) {
+                    treeNodes[i].right = treeNodes[rightIndex];
+                }
+            }
+        }
+        return treeNodes[0];
+    }
+
+    private static final String space = "      ";
+
+    /**
+     * 竖向打印二叉树
+     *
+     * @param root 二叉树根节点
+     */
+    public static void print(TreeNode root) {
+        print(root, 0);
+
+    }
+
+    private static void print(TreeNode node, int deep) {
+        if (node == null) {
+            printSpace(deep);
+            System.out.println("#");
+            return;
+        }
+        print(node.right, deep + 1);
+        printSpace(deep);
+        printNode(node.val, 5);
+        print(node.left, deep + 1);
+    }
+
+    private static void printSpace(int count) {
+        for (int i = 0; i < count; i++) {
+            System.out.printf(space);
+        }
+    }
+
+    private static void printNode(int val, int len) {
+        StringBuilder res = new StringBuilder(val + "<");
+        int spaceNum = len - res.length();
+        for (int i = 0; i < spaceNum; i++) {
+            res.append(" ");
+        }
+        System.out.println(res);
+    }
+}