diff --git a/note/004/README.md b/note/004/README.md
index 521fc440..a711e193 100644
--- a/note/004/README.md
+++ b/note/004/README.md
@@ -47,7 +47,6 @@ The median is (2 + 3)/2 = 2.5
 
 特别地，我们选取 `m = k / 2`，下面是我画的草图，希望能帮助大家理解。
 
-![](https://raw.githubusercontent.com/Blankj/awesome-java-leetcode/master/note/004/my_draw.jpg)
 
 借助上面的理论，你能写出相关代码了吗？
 
diff --git a/src/me/codebase/leetcode/Test.java b/src/me/codebase/leetcode/Test.java
new file mode 100644
index 00000000..37f8a326
--- /dev/null
+++ b/src/me/codebase/leetcode/Test.java
@@ -0,0 +1,11 @@
+package me.codebase.leetcode;
+
+/**
+ * Created by chendong on 2017/12/13.
+ */
+public class Test {
+
+    public static void main(String[] args) {
+
+    }
+}
diff --git a/src/me/codebase/leetcode/_002.java b/src/me/codebase/leetcode/_002.java
new file mode 100644
index 00000000..aa18dddd
--- /dev/null
+++ b/src/me/codebase/leetcode/_002.java
@@ -0,0 +1,38 @@
+package me.codebase.leetcode;
+
+/**
+ * Created by chendong on 2017/12/13.
+ */
+public class _002 {
+
+    private static Node add(Node n1, Node n2) {
+        int over = 0;
+        Node root = null;
+        Node node = null;
+        while (n1 != null && n2 != null) {
+            Node n = new Node(0);
+            n.val = (n1.val + n2.val + over) % 10;
+            over = (n1.val + n2.val) / 10;
+            n1 = n1.next;
+            n2 = n2.next;
+            if (node == null) {
+                node = n;
+                root = node;
+            } else
+                node.next = n;
+            if (node.next != null)
+                node = node.next;
+        }
+        return root;
+    }
+
+    static class Node {
+        int val;
+        Node next;
+
+        public Node(int val) {
+            this.val = val;
+        }
+    }
+
+}
diff --git a/src/me/codebase/leetcode/_004.java b/src/me/codebase/leetcode/_004.java
new file mode 100644
index 00000000..b7515e30
--- /dev/null
+++ b/src/me/codebase/leetcode/_004.java
@@ -0,0 +1,55 @@
+package me.codebase.leetcode;
+
+/**
+ * Created by chendong on 2018/1/2.
+ */
+public class _004 {
+
+
+    public static void main(String[] args) {
+        int[] A = {1, 3, 4, 6};
+        int[] B = {2, 4, 5, 8, 9, 10};
+        int[] C = {1, 2, 3, 4, 4, 5, 6, 8, 9, 10};
+        // 4.5
+
+        Solution solution = new Solution();
+        double median = solution.findMedianSortedArrays(A, B);
+        System.out.println(median);
+//        System.out.println(findMedianSortedArrays(A, B));
+    }
+
+    private static double findMedian(int[] A, int[] B){
+
+
+
+        return 0;
+    }
+
+
+    static class Solution {
+        public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+            int len = nums1.length + nums2.length;
+            if (len % 2 == 0) {
+                return (helper(nums1, 0, nums2, 0, len / 2) + helper(nums1, 0, nums2, 0, len / 2 + 1)) / 2.0;
+            }
+            return helper(nums1, 0, nums2, 0, (len + 1) / 2);
+        }
+
+        private int helper(int[] nums1, int m, int[] nums2, int n, int k) {
+            if (m >= nums1.length) return nums2[n + k - 1];
+            if (n >= nums2.length) return nums1[m + k - 1];
+            if (k == 1) return Math.min(nums1[m], nums2[n]);
+
+            int p1 = m + k / 2 - 1;
+            int p2 = n + k / 2 - 1;
+            int mid1 = p1 < nums1.length ? nums1[p1] : Integer.MAX_VALUE;
+            int mid2 = p2 < nums2.length ? nums2[p2] : Integer.MAX_VALUE;
+            if (mid1 < mid2) {
+                return helper(nums1, m + k / 2, nums2, n, k - k / 2);
+            }
+            return helper(nums1, m, nums2, n + k / 2, k - k / 2);
+        }
+    }
+
+
+}
diff --git a/src/me/codebase/leetcode/_543.java b/src/me/codebase/leetcode/_543.java
new file mode 100644
index 00000000..8857dc0d
--- /dev/null
+++ b/src/me/codebase/leetcode/_543.java
@@ -0,0 +1,20 @@
+package me.codebase.leetcode;
+
+import me.codebase.leetcode.structure.TreeNode;
+
+/**
+ * Created by chendong on 2018/1/10.
+ */
+public class _543 {
+
+    public static void main(String[] args) {
+
+    }
+
+
+    private static TreeNode getTree(){
+
+        return new TreeNode(1);
+
+    }
+}
diff --git a/src/me/codebase/leetcode/_554.java b/src/me/codebase/leetcode/_554.java
new file mode 100644
index 00000000..65e42bed
--- /dev/null
+++ b/src/me/codebase/leetcode/_554.java
@@ -0,0 +1,59 @@
+package me.codebase.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by chendong on 2018/1/5.
+ */
+public class _554 {
+
+    /*
+    input:
+    [[1,2,2,1],
+ [3,1,2],
+ [1,3,2],
+ [2,4],
+ [3,1,2],
+ [1,3,1,1]]
+    output:
+    2
+     */
+
+    public static void main(String[] args) {
+        List<Integer[]> input = new ArrayList<>();
+        input.add(new Integer[]{1, 2, 2, 1});
+        input.add(new Integer[]{3, 1, 2});
+        input.add(new Integer[]{1, 3, 2});
+        input.add(new Integer[]{2, 4});
+        input.add(new Integer[]{3, 1, 2});
+        input.add(new Integer[]{1, 3, 1, 1});
+        System.out.println(solution(input));
+    }
+
+    private static int solution(List<Integer[]> input) {
+        int result = -1;
+        List<List<Integer>> points = new ArrayList<>(input.size());
+        for (Integer[] breaks : input) {
+            List<Integer> list = new ArrayList<>();
+            int point = 0;
+            for (Integer integer : breaks) {
+                point += integer;
+                list.add(point);
+            }
+            points.add(list);
+        }
+        List<Integer> last = points.get(points.size() - 1);
+        for (int i = 0; i < last.size() - 1; i++) {
+            int temp = 0;
+            for (List<Integer> breaks : points) {
+                if (!breaks.contains(last.get(i)))
+                    temp++;
+            }
+            if (result == -1)
+                result = temp;
+            result = temp > result ? result : temp;
+        }
+        return result;
+    }
+}
diff --git a/src/me/codebase/leetcode/algo/MergeSort.java b/src/me/codebase/leetcode/algo/MergeSort.java
new file mode 100644
index 00000000..7f9da962
--- /dev/null
+++ b/src/me/codebase/leetcode/algo/MergeSort.java
@@ -0,0 +1,54 @@
+package me.codebase.leetcode.algo;
+
+import java.util.Arrays;
+
+/**
+ * Created by chendong on 2018/1/12.
+ */
+public class MergeSort implements Sort {
+
+
+    public static void main(String[] args) {
+//        sort(arr);
+        System.out.println(Arrays.toString(new MergeSort().sort(arr)));
+    }
+
+/*    public int[] sort(int[] a){
+        int[] h = a.clone();
+        return a;
+    }*/
+
+
+
+    public int[] sort(int[] a) {
+        int[] helper = a.clone();
+        sort(a, 0, a.length - 1, helper);
+        return arr;
+    }
+
+    private static void sort(int[] a, int lo, int hi, int[] helper) {
+        if (lo >= hi) return;
+        int mid = (lo + hi) / 2;
+        sort(a, lo, mid, helper);
+        sort(a, mid + 1, hi, helper);
+        merge(a, lo, mid, hi, helper);
+    }
+
+    private static void merge(int[] a, int lo, int mid, int hi, int[] helper) {
+
+        System.arraycopy(a, lo, helper, lo, hi + 1 - lo);
+        int i = lo;
+        int j = mid + 1;
+        for (int k = lo; k <= hi; k++) {
+            if (i > mid)
+                a[k] = helper[j++];
+            else if (j > hi)
+                a[k] = helper[i++];
+            else if (helper[i] <= helper[j])
+                a[k] = helper[i++];
+            else
+                a[k] = helper[j++];
+        }
+
+    }
+}
diff --git a/src/me/codebase/leetcode/algo/QuickSort.java b/src/me/codebase/leetcode/algo/QuickSort.java
new file mode 100644
index 00000000..a7c24450
--- /dev/null
+++ b/src/me/codebase/leetcode/algo/QuickSort.java
@@ -0,0 +1,47 @@
+package me.codebase.leetcode.algo;
+
+import java.util.Arrays;
+
+/**
+ * Created by chendong on 2018/1/11.
+ */
+public class QuickSort implements Sort{
+
+
+    public static void main(String[] args) {
+        System.out.println(Arrays.toString(new QuickSort().sort(arr)));
+    }
+
+    public int[] sort(int[] arr) {
+        sort(0, arr.length - 1, arr);
+        return arr;
+    }
+
+    public void sort(int left, int right, int[] arr) {
+        if (right > left) {
+            int mid = partition(left, right, arr);
+            sort(left, mid - 1, arr);
+            sort(mid + 1, right, arr);
+        }
+    }
+
+    private int partition(int left, int right, int[] arr) {
+        int mid = (left + right) / 2;
+        swap(mid, right, arr);
+        int index = left;
+        for (int i = left; i < right; i++) {
+            if (arr[i] < arr[right]) {
+                swap(i, index, arr);
+                index++;
+            }
+        }
+        swap(index, right, arr);
+        return index;
+    }
+
+    private void swap(int i, int j, int[] arr) {
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+}
diff --git a/src/me/codebase/leetcode/algo/Sort.java b/src/me/codebase/leetcode/algo/Sort.java
new file mode 100644
index 00000000..e4419fce
--- /dev/null
+++ b/src/me/codebase/leetcode/algo/Sort.java
@@ -0,0 +1,10 @@
+package me.codebase.leetcode.algo;
+
+/**
+ * Created by chendong on 2018/1/12.
+ */
+public interface Sort {
+
+     int[] arr = {0, 2, 4, 6, 8, 5, 3, 7, 9, 1, 400};
+
+}
diff --git a/src/me/codebase/leetcode/algo/TreeBuilder.java b/src/me/codebase/leetcode/algo/TreeBuilder.java
new file mode 100644
index 00000000..cafbed30
--- /dev/null
+++ b/src/me/codebase/leetcode/algo/TreeBuilder.java
@@ -0,0 +1,13 @@
+package me.codebase.leetcode.algo;
+
+import me.codebase.leetcode.structure.TreeNode;
+
+/**
+ * Created by chendong on 2018/1/12.
+ */
+public class TreeBuilder {
+
+    public static TreeNode getRootNode(){
+        return null;
+    }
+}
diff --git a/src/me/codebase/leetcode/structure/TreeNode.java b/src/me/codebase/leetcode/structure/TreeNode.java
new file mode 100644
index 00000000..99a84f18
--- /dev/null
+++ b/src/me/codebase/leetcode/structure/TreeNode.java
@@ -0,0 +1,14 @@
+package me.codebase.leetcode.structure;
+
+/**
+ * Created by chendong on 2018/1/10.
+ */
+public class TreeNode {
+    int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode(int x) {
+        val = x;
+    }
+}