diff --git a/README.md b/README.md
index 1e00928..05a86af 100644
--- a/README.md
+++ b/README.md
@@ -64,6 +64,7 @@
 - [[11]  Container With Most Water ](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8F%8C%E6%8C%87%E9%92%88/ContainerWithMostWater_11.java)
 - [[26]  Remove Duplicates from Sorted Array](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8F%8C%E6%8C%87%E9%92%88/RemoveDuplicatesfromSortedArray_26.java)
 - [[27]  Remove Element ](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8F%8C%E6%8C%87%E9%92%88/RemoveElement_27.java)
+- [[88]  Merge Sorted Array ](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8F%8C%E6%8C%87%E9%92%88/MergeSortedArray_88.java)
 
 
 ## kSum
@@ -90,6 +91,9 @@
 - [[709]  To Lower Case](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%AD%97%E7%AC%A6%E4%B8%B2/ToLowerCase_709.java)
 - [[804]  Unique Morse Code Words](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%AD%97%E7%AC%A6%E4%B8%B2/UniqueMorseRepresentations_804.java)
 - [[3]  Longest Substring Without Repeating Characters](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%AD%97%E7%AC%A6%E4%B8%B2/LongestSubstringWithoutRepeatingCharacters_3.java)
+- [[14] Longest Common Prefix](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%AD%97%E7%AC%A6%E4%B8%B2/LongestCommonPrefix_14.java)
+- [[13]  Roman to Integer](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%AD%97%E7%AC%A6%E4%B8%B2/RomanToInt_13.java)
+
 
 
 ## 尺取法
@@ -113,6 +117,11 @@
 - [[461]  Hamming Distance](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/HammingDistance_461.java)
 - [[476]  Number Complement](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/NumberComplement_476.java)
 - [[728]  Self Dividing Numbers](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/SelfDividingNumbers_728.java)
+- [[67]  Add Binary](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/AddBinary_67.java)
+- [[9]  Palindrome Number](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/PalindromeNumber_9.java)
+- [[7]  Reverse Integer](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E5%AD%A6/ReverseInteger_7.java)
+
+
 
 ## 数组
 - [[717]  1-bit and 2-bit Characters](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/BitAnd2bitCharacters_717.java)
@@ -124,6 +133,9 @@
 - [[922]  Sort Array By Parity II](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/SortArrayByParityII_922.java)
 - [[766]  Toeplitz Matrix](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/ToeplitzMatrix_766.java)
 - [[867]  Transpose Matrix](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/Transpose_867.java)
+- [[66]   Plus One](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/PlusOne_66.java)
+- [[1]   Two Sum](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%95%B0%E7%BB%84/TwoSum_1.java)
+
 
 ## 栈
 - [[844]  Backspace String Compare](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E6%A0%88/BackspaceStringCompare_844.java)
@@ -197,6 +209,7 @@
 
 ### 二叉树的性质
 - [[669]  Trim a Binary Search Tree](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E4%BA%8C%E5%8F%89%E6%A0%91/%E6%80%A7%E8%B4%A8/TrimBinarySearchTree_669.java)
+- [[110]  Balanced Binary Tree    ](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E4%BA%8C%E5%8F%89%E6%A0%91/%E6%80%A7%E8%B4%A8/BalanceTree_110.java)
 
 
 
@@ -246,6 +259,7 @@
 ### TwoSequenceDP
 - [[72]  Edit Distance](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/TwoSequencesDP/EditDistance_72.java)
 - [[77]  Combinations](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/TwoSequencesDP/LongestCommonSubsequence_77.java)
+- [[53]  Maximum Subarray](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/TwoSequencesDP/MaximumSubarray_53.java)
 
 ### 背包问题
 - [[416] Partition Equal Subset Sum](https://github.com/zaiyunduan123/leetcode-java/blob/master/src/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92/背包问题/PartitionEqualSubsetSum_416.java)
diff --git "a/src/\344\272\214\345\217\211\346\240\221/\346\200\247\350\264\250/BalanceTree_110.java" "b/src/\344\272\214\345\217\211\346\240\221/\346\200\247\350\264\250/BalanceTree_110.java"
new file mode 100644
index 0000000..aa8da71
--- /dev/null
+++ "b/src/\344\272\214\345\217\211\346\240\221/\346\200\247\350\264\250/BalanceTree_110.java"
@@ -0,0 +1,33 @@
+package 二叉树.性质;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/6/23 9:00 PM
+ * <p>
+ * Bottom-up 提前阻断法（复杂度 O(N)）
+ * 在对root做dfs时，会从下至上获得每个root的左右子树高度，当我们发现有一例左右子树高度差 ＞1的情况时return -1，代表此树不是平衡树，后面的高度计算都没有意义了，之后一路return -1，不再做后面的DFS。
+ */
+public class BalanceTree_110 {
+    class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    public boolean isBalanced(TreeNode root) {
+        return height(root) != -1;
+    }
+
+    private int height(TreeNode root) {
+        if (root == null) return 0;
+        int left = height(root.left);
+        if (left == -1) return -1;
+        int right = height(root.right);
+        if (right == -1 || Math.abs(left - right) > 1) return -1;
+        return Math.max(left, right) + 1;
+    }
+}
diff --git "a/src/\345\212\250\346\200\201\350\247\204\345\210\222/TwoSequencesDP/MaximumSubarray_53.java" "b/src/\345\212\250\346\200\201\350\247\204\345\210\222/TwoSequencesDP/MaximumSubarray_53.java"
new file mode 100644
index 0000000..43735fe
--- /dev/null
+++ "b/src/\345\212\250\346\200\201\350\247\204\345\210\222/TwoSequencesDP/MaximumSubarray_53.java"
@@ -0,0 +1,25 @@
+package 动态规划.TwoSequencesDP;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 9:52 AM
+ *
+ * 最大子序和
+ *
+ * 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
+ */
+public class MaximumSubarray_53 {
+    public int maxSubArray(int[] nums) {
+        int len = nums.length;
+        if (len == 0) {
+            return 0;
+        }
+        int segmentSum = nums[0];
+        int res = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            segmentSum = Math.max(nums[i], segmentSum + nums[i]);
+            res = Math.max(segmentSum, res);
+        }
+        return res;
+    }
+}
diff --git "a/src/\345\217\214\346\214\207\351\222\210/MergeSortedArray_88.java" "b/src/\345\217\214\346\214\207\351\222\210/MergeSortedArray_88.java"
new file mode 100644
index 0000000..8cfa133
--- /dev/null
+++ "b/src/\345\217\214\346\214\207\351\222\210/MergeSortedArray_88.java"
@@ -0,0 +1,25 @@
+package 双指针;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/4 11:13 PM
+ *
+ * 合并两个有序数组
+ *
+ * 给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
+ */
+public class MergeSortedArray_88 {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        int i = m - 1;
+        int j = n - 1;
+        int k = m + n - 1;
+
+        while (k >= 0) {
+            if (j < 0 || i >= 0 && nums1[i] > nums2[j]) {
+                nums1[k--] = nums1[i--];
+            } else {
+                nums1[k--] = nums2[j--];
+            }
+        }
+    }
+}
diff --git "a/src/\345\255\227\347\254\246\344\270\262/LongestCommonPrefix_14.java" "b/src/\345\255\227\347\254\246\344\270\262/LongestCommonPrefix_14.java"
new file mode 100644
index 0000000..597e5ee
--- /dev/null
+++ "b/src/\345\255\227\347\254\246\344\270\262/LongestCommonPrefix_14.java"
@@ -0,0 +1,24 @@
+package 字符串;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/6/23 1:53 PM
+ */
+public class LongestCommonPrefix_14 {
+    public static void main(String[] args) {
+        LongestCommonPrefix_14 n = new LongestCommonPrefix_14();
+        String a[] = {"c","acc","ccc"};
+        String s = n.longestCommonPrefix(a);
+    }
+    public String longestCommonPrefix(String[] strs) {
+        if(strs.length == 0) return "";
+        String pre = strs[0];
+        for(int i=1;i<strs.length;i++){
+            while(strs[i].indexOf(pre) != 0){//是否是前缀
+                pre = pre.substring(0, pre.length()-1);
+                if (pre.isEmpty()) return  "";
+            }
+        }
+        return pre;
+    }
+}
diff --git "a/src/\345\255\227\347\254\246\344\270\262/RomanToInt_13.java" "b/src/\345\255\227\347\254\246\344\270\262/RomanToInt_13.java"
new file mode 100644
index 0000000..5398eca
--- /dev/null
+++ "b/src/\345\255\227\347\254\246\344\270\262/RomanToInt_13.java"
@@ -0,0 +1,50 @@
+package 字符串;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/6/23 2:33 PM
+ * <p>
+ * <p>
+ * 思路
+ * 1. 首先将所有的组合可能性列出并添加到哈希表中
+ * 2. 然后对字符串进行遍历，由于组合只有两种，一种是 1 个字符，一种是 2 个字符，其中 2 个字符优先于 1 个字符
+ * 3. 先判断两个字符的组合在哈希表中是否存在，存在则将值取出加到结果 ans 中，并向后移2个字符。不存在则将判断当前 1 个字符是否存在，存在则将值取出加到结果 ans 中，并向后移 1 个字符
+ * 4. 遍历结束返回结果 ans
+ */
+public class RomanToInt_13 {
+    public static void main(String[] args) {
+        RomanToInt_13 r = new RomanToInt_13();
+        r.romanToInt("III");
+    }
+
+    public int romanToInt(String s) {
+        Map<String, Integer> map = new HashMap<>();
+        map.put("I", 1);
+        map.put("IV", 4);
+        map.put("V", 5);
+        map.put("IX", 9);
+        map.put("X", 10);
+        map.put("XL", 40);
+        map.put("L", 50);
+        map.put("XC", 90);
+        map.put("C", 100);
+        map.put("CD", 400);
+        map.put("D", 500);
+        map.put("CM", 900);
+        map.put("M", 1000);
+        int res = 0;
+        for (int i = 0; i < s.length(); ) {
+            if (s.length() > i + 1 && map.containsKey(s.substring(i, i + 2))) {
+                res += map.get(s.substring(i, i + 2));
+                i += 2;
+            } else {
+                res += map.get(s.substring(i, i + 1));
+                i++;
+            }
+        }
+        return res;
+    }
+}
diff --git "a/src/\346\225\260\345\255\246/AddBinary_67.java" "b/src/\346\225\260\345\255\246/AddBinary_67.java"
new file mode 100644
index 0000000..ae551ad
--- /dev/null
+++ "b/src/\346\225\260\345\255\246/AddBinary_67.java"
@@ -0,0 +1,27 @@
+package 数学;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 9:36 AM
+ *
+ * 二进制求和
+ *
+ * 给定两个二进制字符串，返回他们的和（用二进制表示）
+ */
+public class AddBinary_67 {
+    /**
+     * 用了两个指针分别指向a和b的末尾，然后每次取出一个字符，转为数字，若无法取出字符则按0处理，然后定义进位carry，初始化为0，将三者加起来，对2取余即为当前位的数字，对2取商即为当前进位的值，记得最后还要判断下carry，如果为1的话，要在结果最前面加上一个1。
+     */
+    public String addBinary(String a, String b) {
+        String res = "";
+        int m = a.length() - 1, n = b.length() - 1, carry = 0;
+        while (m >= 0 || n >= 0) {
+            int p = m >= 0 ? a.charAt(m--) - '0' : 0;
+            int q = n >= 0 ? b.charAt(n--) - '0' : 0;
+            int sum = p + q + carry;
+            res = String.valueOf(sum % 2) + res;//当前数
+            carry = sum / 2;  //进位数
+        }
+        return carry == 1 ? "1" + res : res;
+    }
+}
diff --git "a/src/\346\225\260\345\255\246/PalindromeNumber_9.java" "b/src/\346\225\260\345\255\246/PalindromeNumber_9.java"
new file mode 100644
index 0000000..542c96a
--- /dev/null
+++ "b/src/\346\225\260\345\255\246/PalindromeNumber_9.java"
@@ -0,0 +1,31 @@
+package 数学;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 9:57 AM
+ *
+ * 回文数
+ *
+ * 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
+ */
+public class PalindromeNumber_9 {
+    /**
+     * 思路：如果 计算 1221 / 1000， 则可得首位1， 如果 1221 % 10， 则可得到末尾1，进行比较，然后把中间的22取出继续比较。
+     */
+    public boolean isPalindrome(int x) {
+        if (x < 0)
+            return false;
+        int div = 1;
+        while (x / div >= 10)
+            div *= 10;// 取数字的首位数字
+        while (x > 0) {
+            int left = x / div;
+            int right = x % 10;
+            if (left != right)
+                return false;
+            x = (x % div) / 10; // 去掉头和尾
+            div /= 100; // div除于两位
+        }
+        return true;
+    }
+}
diff --git "a/src/\346\225\260\345\255\246/ReverseInteger_7.java" "b/src/\346\225\260\345\255\246/ReverseInteger_7.java"
new file mode 100644
index 0000000..b339349
--- /dev/null
+++ "b/src/\346\225\260\345\255\246/ReverseInteger_7.java"
@@ -0,0 +1,22 @@
+package 数学;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 9:58 AM
+ *
+ * 整数反转
+ */
+public class ReverseInteger_7 {
+    public int reverse(int x) {
+        if (x == 0)
+            return x;
+        int ret = 0;
+        while (x != 0) {
+            if (ret > 2147483647 / 10 || ret < -2147483647 / 10)
+                return 0;
+            ret = ret * 10 + x % 10;
+            x = x / 10;
+        }
+        return ret;
+    }
+}
diff --git "a/src/\346\225\260\347\273\204/PlusOne_66.java" "b/src/\346\225\260\347\273\204/PlusOne_66.java"
new file mode 100644
index 0000000..da3f099
--- /dev/null
+++ "b/src/\346\225\260\347\273\204/PlusOne_66.java"
@@ -0,0 +1,22 @@
+package 数组;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 9:45 AM
+ */
+public class PlusOne_66 {
+    public int[] plusOne(int[] digits) {
+        int size = digits.length;
+        for (int i = size - 1; i >= 0; i--) {
+            if (digits[i] < 9) {
+                digits[i]++;
+                return digits;
+            }
+            digits[i] = 0;
+        }
+        int[] arr = new int[size + 1];
+        arr[0] = 1;
+        return arr;
+    }
+
+}
diff --git "a/src/\346\225\260\347\273\204/TwoSum_1.java" "b/src/\346\225\260\347\273\204/TwoSum_1.java"
new file mode 100644
index 0000000..c4488fc
--- /dev/null
+++ "b/src/\346\225\260\347\273\204/TwoSum_1.java"
@@ -0,0 +1,30 @@
+package 数组;
+
+import java.util.HashMap;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/4/5 10:01 AM
+ *
+ * 两数之和
+ * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标
+ */
+public class TwoSum_1 {
+    public int[] twoSum(int[] nums, int target) {
+
+        if (nums == null) {
+            return null;
+        }
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            map.put(nums[i], i);
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (map.get(target - nums[i]) != null && map.get(target - nums[i]) != i) {
+                return new int[] { i, map.get(target - nums[i]) };
+
+            }
+        }
+        return null;
+    }
+}
diff --git "a/src/\351\223\276\350\241\250/\345\210\240\351\231\244/RemoveDuplicatesfromSortedList_83.java" "b/src/\351\223\276\350\241\250/\345\210\240\351\231\244/RemoveDuplicatesfromSortedList_83.java"
new file mode 100644
index 0000000..941e2cf
--- /dev/null
+++ "b/src/\351\223\276\350\241\250/\345\210\240\351\231\244/RemoveDuplicatesfromSortedList_83.java"
@@ -0,0 +1,24 @@
+package 链表.删除;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/1/29 下午10:16
+ * 删除排序链表中的重复元素
+ * 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
+ */
+public class RemoveDuplicatesfromSortedList_83 {
+    class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+        }
+    }
+
+    public ListNode deleteDuplicates(ListNode head) {
+        if(head == null || head.next == null) return head;
+        head.next = deleteDuplicates(head.next);
+        return head.val == head.next.val ? head.next : head;
+    }
+}
diff --git "a/src/\351\223\276\350\241\250/\345\217\215\350\275\254/RotateRight_61.java" "b/src/\351\223\276\350\241\250/\345\217\215\350\275\254/RotateRight_61.java"
new file mode 100644
index 0000000..532797f
--- /dev/null
+++ "b/src/\351\223\276\350\241\250/\345\217\215\350\275\254/RotateRight_61.java"
@@ -0,0 +1,43 @@
+package 链表.反转;
+
+/**
+ * @Author jiangyunxiong
+ * @Date 2019/1/29 下午9:55
+ * 旋转链表
+ * 给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
+ */
+public class RotateRight_61 {
+    class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+        }
+    }
+
+    /**
+     * 思路：
+     * <p>
+     * 1. 先求出整个链表的长度
+     * 2. 根据k值找到需要移动的部分链表的前驱(l-n%l)
+     * 3. 在前驱之后将链表断开，移动后半部分
+     */
+    public ListNode rotateRight(ListNode head, int k) {
+        if (head == null || head.next == null) return head;
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode fast = dummy, slow = dummy;
+        int i;
+        for (i = 0; fast.next != null; i++) {
+            fast = fast.next;
+        }
+        for (int j = i - k % i; j > 0; j--) {
+            slow = slow.next;
+        }
+        fast.next = dummy.next;//翻转
+        dummy.next = slow.next;
+        slow.next = null;
+        return dummy.next;
+    }
+}