diff --git a/algorithm/pom.xml b/algorithm/pom.xml
new file mode 100644
index 0000000..629cdd0
--- /dev/null
+++ b/algorithm/pom.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.andy</groupId>
+    <artifactId>leetcode</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>7.6.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>JUNIT</groupId>
+            <artifactId>JUNIT</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.12.0</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>JUNIT</groupId>
+            <artifactId>JUNIT</artifactId>
+            <version>4.12</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+
+</project>
\ No newline at end of file
diff --git a/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversal.java b/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversal.java
new file mode 100644
index 0000000..a6a5e2e
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversal.java
@@ -0,0 +1,49 @@
+package BFS_DFS;
+
+import binaryTree.TreeNode;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/**
+ *  102. 二叉树层序遍历
+ */
+
+public class BinaryTreeLevelOrderTraversal {
+
+    public ArrayList<ArrayList<Integer>> binaryTreeLevelOrderTraversal(TreeNode root) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+
+        // 设置一个队列，队列中存放根节点
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while(!queue.isEmpty()) {
+            int size = queue.size();
+            // 将当前队列中的所有节点向四周扩散
+            ArrayList<Integer> temp = new ArrayList<>();
+            for(int i=0; i<size; i++) {
+                // 获取当前节点
+                TreeNode cur = queue.poll();
+                temp.add(cur.val);
+
+                // 添加到队列中
+                if(cur.left != null) {
+                    queue.add(cur.left);
+                }
+                if(cur.right != null) {
+                    queue.add(cur.right);
+                }
+            }
+            res.add(temp);
+        }
+
+
+        return res;
+    }
+
+
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversalII.java b/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversalII.java
new file mode 100644
index 0000000..87f12c3
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/BinaryTreeLevelOrderTraversalII.java
@@ -0,0 +1,44 @@
+package BFS_DFS;
+
+/**
+ * 107 二叉树的层序遍历 II
+ */
+
+import binaryTree.TreeNode;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinaryTreeLevelOrderTraversalII {
+
+    public ArrayList<ArrayList<Integer>> binaryTreeLevelOrderTraverseII(TreeNode root) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while(!queue.isEmpty()) {
+            int size = queue.size();
+            ArrayList<Integer> temp = new ArrayList<>();
+
+            for(int i=0; i<size; i++) {
+                TreeNode cur = queue.poll();
+                temp.add(cur.val);
+
+                if(cur.left!=null) {
+                    queue.offer(cur.left);
+                }
+                if(cur.right!=null) {
+                    queue.offer(cur.right);
+                }
+            }
+
+            res.add(0, temp);
+        }
+
+        return  res;
+    }
+
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.java b/algorithm/src/main/java/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.java
new file mode 100644
index 0000000..b1f89d0
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.java
@@ -0,0 +1,58 @@
+package BFS_DFS;
+
+import binaryTree.TreeNode;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ *  103. 二叉树锯齿形层序遍历
+ */
+
+public class BinaryTreeZigzagLevelOrderTraversal {
+
+    public ArrayList<ArrayList<Integer>> binaryTreeZigzagLevelOrderTraversal(TreeNode root) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+
+        if(root==null) {
+            return res;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        // 用于记录遍历方向
+        boolean leftToRight = false;
+        while(!queue.isEmpty()) {
+            int size = queue.size();
+
+            ArrayList<Integer> temp = new ArrayList<>();
+
+            for(int i=0; i<size; i++) {
+                TreeNode cur = queue.poll();
+                temp.add(cur.val);
+
+                if(cur.left!=null) {
+                    if(leftToRight) {
+                        queue.offer(cur.left);
+                    } else {
+                        queue.offer(cur.right);
+                    }
+
+                    if(leftToRight) {
+                        queue.offer(cur.right);
+                    } else {
+                        queue.offer(cur.left);
+                    }
+                }
+            }
+            res.add(temp);
+
+            // 改变遍历方向
+            leftToRight = !leftToRight;
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/CountSubIslands.java b/algorithm/src/main/java/BFS_DFS/CountSubIslands.java
new file mode 100644
index 0000000..feaeec9
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/CountSubIslands.java
@@ -0,0 +1,51 @@
+package BFS_DFS;
+
+/**
+ *  1905 统计子岛屿
+ */
+
+public class CountSubIslands {
+
+    public int countSubIsland(int[][] grid1, int[][] grid2) {
+        int res=0;
+
+        // 预处理，淹没掉非子岛
+        for(int i=0; i< grid1.length; i++) {
+            for(int j=0; j<grid1[0].length; j++) {
+                if(grid1[i][j]==0 && grid2[i][j]==1) {
+                    // 淹没掉grid2岛
+                    dfs(i, j, grid2);
+                }
+            }
+        }
+
+        // 计算子岛
+        for(int i=0; i<grid2.length;i++) {
+            for(int j=0; j<grid2[0].length; j++) {
+                if(grid2[i][j]==1) {
+                    dfs(i, j, grid2);
+                    res += 1;
+                }
+            }
+        }
+
+        return res;
+    }
+
+    void dfs(int i, int j, int[][] grid) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+
+        if(grid[i][j]==0) {
+            return;
+        }
+
+        grid[i][j]=0;
+        dfs(i-1, j, grid);
+        dfs(i+1, j, grid);
+        dfs(i,j-1, grid);
+        dfs(i, j+1, grid);
+
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/MaxAreaIsland.java b/algorithm/src/main/java/BFS_DFS/MaxAreaIsland.java
new file mode 100644
index 0000000..5528dfc
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/MaxAreaIsland.java
@@ -0,0 +1,44 @@
+package BFS_DFS;
+
+/**
+ * 695 岛屿最大面积
+ */
+
+public class MaxAreaIsland {
+
+    int area = 0;
+
+    public int maxAreaIsland(int[][] grid) {
+        int res=0;
+        for(int i=0; i<grid.length; i++) {
+            for(int j=0; j<grid[0].length; j++) {
+                if(grid[i][j]==1) {
+                    dfs(i, j, grid);
+                    res = Math.max(res, area);
+                    area = 0;
+                }
+            }
+        }
+
+        return res;
+    }
+
+    void dfs(int i, int j, int[][] grid) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+
+        if(grid[i][j]==0) {
+            return;
+        }
+
+        grid[i][j]=0;
+        area += 1;
+        dfs(i-1, j, grid);
+        dfs(i+1, j, grid);
+        dfs(i, j-1, grid);
+        dfs(i, j+1, grid);
+    }
+
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/MinimumDepthBinaryTree.java b/algorithm/src/main/java/BFS_DFS/MinimumDepthBinaryTree.java
new file mode 100644
index 0000000..0feea89
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/MinimumDepthBinaryTree.java
@@ -0,0 +1,40 @@
+package BFS_DFS;
+
+import binaryTree.TreeNode;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 111. 二叉树的最小深度
+ */
+
+public class MinimumDepthBinaryTree {
+
+    public int minimumDepthBinaryTree(TreeNode root) {
+        int res = 0;
+
+        if(root==null) {
+            return res;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        res += 1;
+
+        while (!queue.isEmpty()) {
+            int sz = queue.size();
+
+            for(int i=0; i<sz; i++) {
+                TreeNode cur = queue.poll();
+                if(cur.left==null || cur.right==null) {
+                    return res;
+                }
+            }
+
+            res += 1;
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/NumberClosedIslands.java b/algorithm/src/main/java/BFS_DFS/NumberClosedIslands.java
new file mode 100644
index 0000000..48b0091
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/NumberClosedIslands.java
@@ -0,0 +1,51 @@
+package BFS_DFS;
+
+/**
+ * 1254 统计封闭岛屿的数量
+ */
+
+
+public class NumberClosedIslands {
+
+    public int numberClosedIslands(int[][] grid) {
+        int res=0;
+
+        for(int i=0; i<grid.length; i++) {
+            dfs(i, 0, grid);
+            dfs(i, grid[0].length-1, grid);
+        }
+
+        for(int j=0; j<grid[0].length; j++) {
+            dfs(0, j, grid);
+            dfs(grid.length-1, j, grid);
+        }
+
+        for(int i=0;i<grid.length;i++) {
+            for(int j=0;j<grid[0].length; j++) {
+                if(grid[i][j]==0) {
+                    res += 1;
+                    dfs(i, j, grid);
+                }
+            }
+        }
+
+        return res;
+    }
+
+    void dfs(int i, int j, int[][] grid) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+
+        // 海水
+        if(grid[i][j]==1) {
+            return;
+        }
+
+        grid[i][j]=1;
+        dfs(i-1, j, grid);
+        dfs(i+1, j, grid);
+        dfs(i, j-1, grid);
+        dfs(i, j+1, grid);
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/NumberDistinctIslands.java b/algorithm/src/main/java/BFS_DFS/NumberDistinctIslands.java
new file mode 100644
index 0000000..009716b
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/NumberDistinctIslands.java
@@ -0,0 +1,59 @@
+package BFS_DFS;
+
+import java.util.ArrayList;
+
+/**
+ * 694 不同的岛屿数量
+ */
+
+public class NumberDistinctIslands {
+
+    public int numberDistinctIslands(char[][] grid) {
+        int res = 0;
+        ArrayList<String> shape = new ArrayList<>();
+        StringBuilder temp = new StringBuilder();
+        for(int i=0; i<grid.length; i++) {
+            for(int j=0; j<grid[0].length; j++) {
+                if(grid[i][j]=='1') {
+                    dfs(i, j, grid, temp, "");
+                    if(!contain(temp.toString(), shape)) {
+                        res += 1;
+                        shape.add(temp.toString());
+                    }
+                    temp.delete(0, temp.length());
+                }
+            }
+        }
+
+        return res;
+    }
+
+    void dfs(int i, int j, char[][] grid, StringBuilder s, String dir) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+        if(grid[i][j]=='0') {
+            return;
+        }
+
+        // 记录外形
+        s.append(dir);
+
+        grid[i][j]='0';
+        dfs(i-1, j, grid, s, "1");
+        dfs(i+1, j, grid, s, "2");
+        dfs(i, j-1, grid, s, "3");
+        dfs(i, j+1, grid, s, "4");
+
+    }
+
+    boolean contain(String s, ArrayList<String> shape) {
+        for(String t: shape) {
+            if(t.equals(s)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/NumberEnclaves.java b/algorithm/src/main/java/BFS_DFS/NumberEnclaves.java
new file mode 100644
index 0000000..ef87c27
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/NumberEnclaves.java
@@ -0,0 +1,54 @@
+package BFS_DFS;
+
+/**
+ * 1020 飞地的数量
+ */
+
+public class NumberEnclaves {
+
+    int res = 0;
+
+    public int numberEnclaves(int[][] grid) {
+
+        int m=grid.length, n=grid[0].length;
+
+
+        for(int i=0; i<m;i++) {
+            for(int j=0; j<n;j++) {
+                if(grid[i][j]==1) {
+                    if (i == 0 || i == grid.length - 2 && j == 0 || j == grid[0].length - 2) {
+                        // 排除该位置为岛屿
+                        dfs(i, j, grid);
+                        res -= 1;
+                    } else{
+                        // 发现岛屿
+                        dfs(i, j, grid);
+                    }
+                }
+            }
+        }
+
+
+        return res;
+    }
+
+    void dfs(int i, int j, int[][] grid) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+
+        if(grid[i][j]==0) {
+            return;
+        }
+
+
+        grid[i][j] = 0;
+        res += 1;
+        dfs(i, j-1, grid); // 上
+        dfs(i, j+1, grid); // 下
+        dfs(i-1, j, grid); // 左
+        dfs(i+1, j, grid); // 右
+
+
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/NumberIslands.java b/algorithm/src/main/java/BFS_DFS/NumberIslands.java
new file mode 100644
index 0000000..1431bd5
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/NumberIslands.java
@@ -0,0 +1,41 @@
+package BFS_DFS;
+
+/**
+ * 200 岛屿数量
+ */
+
+public class NumberIslands {
+
+    public int numberIslands(char[][] grid) {
+        int res = 0;
+
+        for(int i=0; i<grid.length; i++) {
+            for(int j=0; j<grid[0].length; j++) {
+                if(grid[i][j]=='1') {
+                    dfs(i, j, grid);
+                    res += 1;
+                }
+            }
+        }
+
+        return res;
+    }
+
+    void dfs(int i, int j, char[][] grid) {
+        if(i<0 || j<0 || i>=grid.length || j>=grid[0].length) {
+            return;
+        }
+
+        if(grid[i][j]=='0') {
+            return;
+        }
+
+        grid[i][j]='0';
+        dfs(i-1,j,grid);
+        dfs(i+1, j, grid);
+        dfs(i, j-1, grid);
+        dfs(i, j+1, grid);
+    }
+
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/OpenTheLock.java b/algorithm/src/main/java/BFS_DFS/OpenTheLock.java
new file mode 100644
index 0000000..a4782d9
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/OpenTheLock.java
@@ -0,0 +1,70 @@
+package BFS_DFS;
+
+import java.util.*;
+
+/**
+ * 752. 打开转盘锁
+ */
+
+public class OpenTheLock {
+
+    public int openTheLock(ArrayList<String> depends, String target) {
+        int res = 0;
+        Queue<String> queue = new LinkedList<>();
+        Set<String> visited = new HashSet<>(depends);
+        queue.add("0000");
+
+        while (!queue.isEmpty()) {
+            int sz = queue.size();
+
+            for(int i=0; i<sz; i++) {
+                String cur = queue.poll();
+//                System.out.println(sz);
+                if(visited.contains(cur)) {
+                    continue;
+                } else {
+                    visited.add(cur);
+                }
+
+                if(target.equals(cur)) {
+                    return res;
+                }
+//                assert cur != null;
+                for(int m = 0; m<cur.length(); m++) {
+                    String sMinus = minusOne(cur, m);
+                    String sPlus = plusOne(cur, m);
+                    queue.add(sMinus);
+                    queue.add(sPlus);
+                }
+            }
+            res += 1;
+        }
+
+        return -1;
+    }
+
+    // 将s[i] 向下拨动一位
+    String minusOne(String s, int i) {
+        char[] ch = s.toCharArray();
+        if(ch[i]=='0') {
+            ch[i] = '9';
+        } else {
+            ch[i] -= 1;
+        }
+        return new String(ch);
+    }
+
+    // 将s[i] 向上拨动一位
+    String plusOne(String s, int i) {
+        char[] ch = s.toCharArray();
+        if(ch[i]=='9') {
+            ch[i] = '0';
+        } else {
+            ch[i] += 1;
+        }
+        return new String(ch);
+    }
+
+
+
+}
diff --git a/algorithm/src/main/java/BFS_DFS/SlidingPuzzle.java b/algorithm/src/main/java/BFS_DFS/SlidingPuzzle.java
new file mode 100644
index 0000000..a872a2b
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/SlidingPuzzle.java
@@ -0,0 +1,98 @@
+package BFS_DFS;
+
+import jdk.nashorn.internal.ir.WhileNode;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
+
+/**
+ *  773. 滑动谜题
+ */
+
+public class SlidingPuzzle {
+
+    public int slidingPuzzle(int[][] nums) {
+        int res = 0;
+        Queue<String> queue = new LinkedList<>();
+        Set<String> visited = new HashSet<>();
+        String target = "123450";
+        StringBuilder sb = new StringBuilder();
+        for(int i=0;i<nums.length; i++) {
+            for(int j=0;j<nums[0].length;j++) {
+                sb.append(nums[i][j]);
+            }
+        }
+
+        queue.add(sb.toString());
+        while(!queue.isEmpty()) {
+            int sz = queue.size();
+
+            for(int i=0; i< sz; i++) {
+                String cur = queue.poll();
+
+                if(visited.contains(cur)) {
+                    continue;
+                } else {
+                    visited.add(cur);
+                }
+
+                if(cur.equals(target)) {
+                    return res;
+                }
+
+                // 遍历得到'0'的索引
+                int index = 0;
+                for(;index<cur.length(); index+=1) {
+                    if(cur.charAt(index)=='0') {
+                        break;
+                    }
+                }
+
+                int row = index/nums[0].length;
+                int col = index%nums[0].length;
+
+                // 左交换
+                if(col>0) {
+                    String sLeft = swap(cur, index, index-1);
+                    queue.add(sLeft);
+                }
+                // 右交换
+                if(col<nums[0].length-1) {
+                    String sRight = swap(cur, index, index+1);
+                    queue.add(sRight);
+                }
+
+                // 上交换
+                if(row>0) {
+                    String sTop = swap(cur, index, index-nums[0].length);
+                    queue.add(sTop);
+                }
+
+                // 下交换
+                if(row<nums.length-1) {
+                    String sBottom = swap(cur, index, index+nums[0].length);
+                    queue.add(sBottom);
+                }
+
+            }
+
+            res += 1;
+        }
+
+        return -1;
+
+
+    }
+
+    String swap(String s, int i, int j) {
+//        System.out.println(s+" "+i+" "+j);
+        char[] ch = s.toCharArray();
+        char temp = ch[i];
+        ch[i] = ch[j];
+        ch[j] = temp;
+        return new String(ch);
+
+    }
+}
diff --git a/algorithm/src/main/java/BFS_DFS/SurroundedRegions.java b/algorithm/src/main/java/BFS_DFS/SurroundedRegions.java
new file mode 100644
index 0000000..7147f82
--- /dev/null
+++ b/algorithm/src/main/java/BFS_DFS/SurroundedRegions.java
@@ -0,0 +1,70 @@
+package BFS_DFS;
+
+/**
+ *  130. 被围绕的区域
+ */
+
+// 先用 for 循环遍历棋盘的四边，用 DFS 算法把那些与边界相连的 O 换成一个特殊字符，比如 #；
+// 然后再遍历整个棋盘，把剩下的 O 换成 X，把 # 恢复成 O。
+// 这样就能完成题目的要求，时间复杂度 O(MN)。
+public class SurroundedRegions {
+
+    public char[][] surroundedRegions(char[][] board) {
+
+        int res = 0;
+        int m = board.length, n= board[0].length;
+
+        // 遍历周边岛屿，并标记 O 为 '#'
+        for(int i=0; i<m; i++) {
+            for(int j=0; j<n; j++) {
+                if(i==0 || i==board.length-1) {
+
+                    if(board[i][j] == 'O') {
+                        dfs(i, j, board);
+                    }
+                } else if(j==0 || j==board[0].length-1) {
+                    if(board[i][j] == 'O') {
+                        dfs(i, j, board);
+                    }
+                }
+            }
+        }
+
+        // 将 # 标记为 O，将 O 标识为X
+        for(int i=0; i<m; i++) {
+            for(int j=0; j<n; j++) {
+                if(board[i][j] == 'O') {
+                    board[i][j] = 'X';
+                }else if(board[i][j] == '#') {
+                    board[i][j] = 'O';
+                }
+            }
+        }
+
+        return board;
+    }
+
+    void dfs(int row, int col, char[][] board) {
+        int m=board.length, n=board[0].length;
+        if(row<0 || col<0 || row>=m || col>=n) {
+            // 超出搜索边界
+            return;
+        }
+
+        if(board[row][col]=='X') {
+            // 已经是海水
+            return;
+        }
+        // 将(row, col)变成海水，标记为 #
+        board[row][col] = '#';
+        // 淹没上下左右陆地
+        dfs(row+1, col, board);
+        dfs(row, col+1, board);
+        dfs(row-1, col, board);
+        dfs(row-1, col-1, board);
+    }
+
+
+
+
+}
diff --git a/algorithm/src/main/java/DP/BloodSimilarity.java b/algorithm/src/main/java/DP/BloodSimilarity.java
new file mode 100644
index 0000000..b34a4af
--- /dev/null
+++ b/algorithm/src/main/java/DP/BloodSimilarity.java
@@ -0,0 +1,42 @@
+package DP;
+
+import java.util.Scanner;
+
+/**
+ * 字节跳动 -- 古生物血缘远近判定
+ */
+
+public class BloodSimilarity {
+
+    public int bloodSimilarity(String str1, String str2){
+        int res = 0;
+
+        res = traverse(str1, 0, str2, 0, 0);
+        return res;
+    }
+
+    int traverse(String str1, int pos1, String str2, int pos2, int res){
+        if(pos1==str1.length()) {
+            return res+str2.length()-pos2;
+        }else if(pos2==str2.length()){
+            return res+str1.length()-pos1;
+        }
+
+        if(str1.charAt(pos1)==str2.charAt(pos2)) {
+            return traverse(str1, pos1+1, str2, pos2+1, res);
+        }
+
+        int res1 = traverse(str1, pos1+1, str2, pos2, res+1);
+        int res2 = traverse(str1, pos1, str2, pos2+1, res+1);
+        int res3 = traverse(str1, pos1+1, str2, pos2+1, res+1);
+        return Math.min(res1, Math.min(res2, res3));
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        String[] strs = sc.nextLine().trim().split(",");
+        BloodSimilarity solver = new BloodSimilarity();
+        int res = solver.bloodSimilarity(strs[0], strs[1]);
+        System.out.print(res);
+    }
+}
diff --git a/algorithm/src/main/java/DP/DisjointLines.java b/algorithm/src/main/java/DP/DisjointLines.java
new file mode 100644
index 0000000..873003a
--- /dev/null
+++ b/algorithm/src/main/java/DP/DisjointLines.java
@@ -0,0 +1,41 @@
+package DP;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * 1035 不相交的线
+ */
+
+public class DisjointLines {
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        int res=0;
+        int[][] memo = new int[nums1.length][nums2.length];
+        for(int[] ints: memo){
+            Arrays.fill(ints,-1);
+        }
+
+        res = dp(nums1, nums1.length-1, nums2, nums2.length-1, memo);
+        return  res;
+    }
+
+    int dp(int[] nums1, int p1, int[] nums2, int p2, int[][] memo){
+        if(p1<0 || p2<0) {
+            return 0;
+        }
+
+        if(memo[p1][p2]!=-1) {
+            return memo[p1][p2];
+        }
+        if(nums1[p1]==nums2[p2]) {
+            memo[p1][p2] = dp(nums1, p1-1, nums2, p2-1, memo)+1;
+        }else {
+            memo[p1][p2] = Math.max(
+                    dp(nums1, p1-1, nums2, p2, memo),
+                    dp(nums1, p1, nums2, p2-1, memo)
+                    );
+        }
+
+        return memo[p1][p2];
+    }
+}
diff --git a/algorithm/src/main/java/DP/Envelops.java b/algorithm/src/main/java/DP/Envelops.java
new file mode 100644
index 0000000..ceb488e
--- /dev/null
+++ b/algorithm/src/main/java/DP/Envelops.java
@@ -0,0 +1,28 @@
+package DP;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * 354. 俄罗斯套娃信封问题
+ *
+ * 思路：对信封进行排序。先比较width，width相同则比较height
+ */
+
+public class Envelops {
+
+    public int maxEnvelops(int[][] envelops) {
+        int res = 0;
+        // 对二维数组进行排序
+        Arrays.sort(envelops, new Comparator<int[]>() {
+            public int compare(int[] a, int[] b) {
+                if(a[0]==b[0]) {
+                    return a[1]-b[1];
+                }
+                return a[0]-b[0];
+            }
+        });
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/DP/IsSubsequence.java b/algorithm/src/main/java/DP/IsSubsequence.java
new file mode 100644
index 0000000..91a51eb
--- /dev/null
+++ b/algorithm/src/main/java/DP/IsSubsequence.java
@@ -0,0 +1,27 @@
+package DP;
+
+/**
+ * 392 判断子序列
+ */
+
+public class IsSubsequence {
+
+    public boolean isSubsequence(String s, String t) {
+        boolean res = true;
+        res = dp(s, s.length()-1, t, t.length()-1);
+        return res;
+    }
+
+    boolean dp(String s, int p1, String t, int p2){
+        if(p1<0){
+            return true;
+        }else if(p2<0){
+            return false;
+        }
+        if(s.charAt(p1)==t.charAt(p2)){
+            return dp(s, p1-1, t, p2-1);
+        }else {
+            return dp(s, p1, t, p2-1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/DP/LongestCommonSubsequence.java b/algorithm/src/main/java/DP/LongestCommonSubsequence.java
new file mode 100644
index 0000000..dd13986
--- /dev/null
+++ b/algorithm/src/main/java/DP/LongestCommonSubsequence.java
@@ -0,0 +1,25 @@
+package DP;
+
+/**
+ * 1143 最长公共子序列
+ */
+
+public class LongestCommonSubsequence {
+
+    public int longestCommonSubsequence(String text1, String text2){
+        int res = 0;
+        res = dp(text1, 0, text2, 0);
+
+        return  res;
+    }
+
+    int dp(String text1, int p1, String text2, int p2){
+        if(p1>=text1.length() || p2>=text2.length()) {
+            return 0;
+        }
+        if(text1.charAt(p1)==text2.charAt(p2)){
+            return dp(text1, p1+1, text2, p2+1)+1;
+        }
+        return Math.max(dp(text1, p1+1, text2, p2), dp(text1, p1, text2, p2+1));
+    }
+}
diff --git a/algorithm/src/main/java/DP/LongestCommonSubsequenceII.java b/algorithm/src/main/java/DP/LongestCommonSubsequenceII.java
new file mode 100644
index 0000000..06dd809
--- /dev/null
+++ b/algorithm/src/main/java/DP/LongestCommonSubsequenceII.java
@@ -0,0 +1,40 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ * 1143 最长公共子序列
+ */
+
+public class LongestCommonSubsequenceII {
+
+    public int longestCommonSubsequence(String text1, String text2){
+        int res = 0;
+        int[][] memo = new int[text1.length()][text2.length()];
+        for (int[] ints : memo) {
+            Arrays.fill(ints, -1);
+        }
+        res = dp(text1, text1.length()-1, text2, text2.length()-1, memo);
+
+        return  res;
+    }
+
+    int dp(String text1, int p1, String text2, int p2, int[][] memo){
+        if(p1<0 || p2<0) {
+            return 0;
+        }
+        // 查询备忘录中是否存在数据
+        if(memo[p1][p2]!=-1){
+            return memo[p1][p2];
+        }
+
+        if(text1.charAt(p1)==text2.charAt(p2)){
+            memo[p1][p2] = dp(text1, p1-1, text2, p2-1, memo)+1;
+        }else {
+            memo[p1][p2] = Math.max(dp(text1, p1 - 1, text2, p2, memo),
+                                    dp(text1, p1, text2, p2 - 1, memo)
+            );
+        }
+        return memo[p1][p2];
+    }
+}
diff --git a/algorithm/src/main/java/DP/MinFallingPathSum.java b/algorithm/src/main/java/DP/MinFallingPathSum.java
new file mode 100644
index 0000000..d5ebe63
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinFallingPathSum.java
@@ -0,0 +1,65 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ * 931 最小下降和
+ */
+
+public class MinFallingPathSum {
+
+    public int minFallingPathSum(int[][] matrix) {
+        int res = Integer.MAX_VALUE;
+        int[][] memo = new int[matrix.length][matrix[0].length]; // 创建备忘录
+        for(int[] t: memo) {
+            Arrays.fill(t, Integer.MAX_VALUE);
+        }
+
+        dp(matrix.length-1, matrix[0].length-1, matrix, memo);
+        for(int i=0; i<memo[0].length; i++) {
+            res = Math.min(res, memo[matrix.length-1][i]);
+        }
+
+        return res;
+
+    }
+
+    int dp(int row, int col, int[][] matrix, int[][] memo) {
+        if(row<0 || col<0) {
+            return 0;
+        }
+
+        if(memo[row][col]!=Integer.MAX_VALUE) {
+            return memo[row][col];
+        }
+
+
+        for(int i=0; i<matrix[0].length; i++) {
+            // 第一列
+            if(i==0) {
+                // 列数大于1
+                if(matrix[0].length>1) {
+                    memo[row][i] = Math.min(dp(row - 1, i, matrix, memo), dp(row - 1, i + 1, matrix, memo))+matrix[row][i];
+                }else{
+                    // 列数为1列
+                    memo[row][i] = dp(row-1, i, matrix, memo)+ matrix[row][i];
+                }
+            }else if(i+1==matrix[0].length) {
+                // 最后一列（默认列数大于1）
+                memo[row][i] =  Math.min(dp(row-1, i-1, matrix, memo), dp(row-1, i, matrix, memo))+matrix[row][i];
+            }else {
+                memo[row][i] = Math.min(
+                        dp(row - 1, i - 1, matrix, memo),
+                        Math.min(
+                                dp(row - 1, i, matrix, memo),
+                                dp(row - 1, i + 1, matrix, memo)
+                        )
+                ) + matrix[row][i];
+            }
+
+        }
+        return memo[row][col];
+    }
+
+
+}
diff --git a/algorithm/src/main/java/DP/MinFallingPathSum2.java b/algorithm/src/main/java/DP/MinFallingPathSum2.java
new file mode 100644
index 0000000..bb6359b
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinFallingPathSum2.java
@@ -0,0 +1,49 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ *  1289. 下降路径最小和II
+ */
+
+public class MinFallingPathSum2 {
+    public int minFallingPathSum(int[][] grid) {
+        int res = Integer.MAX_VALUE;
+        int[][] memo = new int[grid.length][grid[0].length];
+        for(int[] t: memo) {
+            Arrays.fill(t, Integer.MAX_VALUE);
+        }
+        dp(grid.length-1, grid[0].length-1, grid, memo);
+        for(int i=0; i<memo[0].length; i++) {
+            res = Math.min(res, memo[grid.length-1][i]);
+        }
+
+        return res;
+    }
+
+    int dp(int row, int col, int[][] grid, int[][] memo) {
+        if(row<0 || col<0) {
+            return 0;
+        }
+
+        if(memo[row][col]!=Integer.MAX_VALUE) {
+            return memo[row][col];
+        }
+
+        for(int i=0; i<grid[0].length; i++) {
+            int temp = Integer.MAX_VALUE;
+            // 处理仅有一列的情况
+            if(grid[0].length==1) {
+                temp = dp(row-1, i, grid, memo);
+            }
+            for(int j=0; j<grid[0].length; j++) {
+                if(i==j) {
+                    continue;
+                }
+                temp = Math.min(temp, dp(row-1, j, grid, memo));
+            }
+            memo[row][i] = temp + grid[row][i];
+        }
+        return memo[row][col];
+    }
+}
diff --git a/algorithm/src/main/java/DP/MinFallingPathSumII.java b/algorithm/src/main/java/DP/MinFallingPathSumII.java
new file mode 100644
index 0000000..74cf5fa
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinFallingPathSumII.java
@@ -0,0 +1,55 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ * 931 最小下降和（简化if判断）
+ */
+
+public class MinFallingPathSumII {
+
+    public int minFallingPathSum(int[][] matrix) {
+        int res = Integer.MAX_VALUE;
+        int[][] memo = new int[matrix.length][matrix[0].length]; // 创建备忘录
+        for(int[] t: memo) {
+            Arrays.fill(t, Integer.MAX_VALUE);
+        }
+
+        dp(matrix.length-1, matrix[0].length-1, matrix, memo);
+        for(int i=0; i<memo[0].length; i++) {
+            res = Math.min(res, memo[matrix.length-1][i]);
+        }
+
+        return res;
+
+    }
+
+    int dp(int row, int col, int[][] matrix, int[][] memo) {
+        if(row<0 || col<0) {
+            return 0;
+        }
+
+        if(memo[row][col]!=Integer.MAX_VALUE) {
+            return memo[row][col];
+        }
+
+
+        int temp;
+        for(int i=0; i<matrix[0].length; i++) {
+            temp = dp(row-1, i, matrix, memo);
+            // 列数大于1，且当前列数大于1，那么比较
+            if(matrix[0].length>1 && i>0){
+                temp = Math.min(temp, dp(row-1, i-1, matrix, memo));
+            }
+            // 列数大于1，且未到达最右侧，那么比较
+            if(matrix[0].length>1 && i+1<matrix[0].length) {
+                temp = Math.min(temp, dp(row-1, i+1, matrix, memo));
+            }
+
+            memo[row][i] = temp + matrix[row][i];
+            }
+        return memo[row][col];
+    }
+
+
+}
diff --git a/algorithm/src/main/java/DP/MinPathSum.java b/algorithm/src/main/java/DP/MinPathSum.java
new file mode 100644
index 0000000..fd63fca
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinPathSum.java
@@ -0,0 +1,42 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ *  64 最小路径和
+ */
+
+public class MinPathSum {
+    public int minPathSum(int[][] grid) {
+        int res = 0;
+        int[][] memo = new int[grid.length][grid[0].length];
+        for(int[] t: memo){
+            Arrays.fill(t, -1);
+        }
+
+        res = dp(grid.length-1, grid[0].length-1, memo, grid);
+
+        return res;
+    }
+
+    int dp(int row, int col, int[][] memo, int[][] grid){
+        if(row<0 || col<0){
+            return 0;
+        }
+
+        if(memo[row][col]!=-1){
+            return memo[row][col];
+        }
+
+        if(row==0) {
+            memo[row][col] = dp(row, col-1, memo, grid)+grid[row][col];
+        }else if(col==0) {
+            memo[row][col] = dp(row-1, col, memo, grid)+grid[row][col];
+        }else {
+            memo[row][col] = Math.min(
+                    dp(row - 1, col, memo, grid),
+                    dp(row, col - 1, memo, grid))+grid[row][col];
+        }
+        return memo[row][col];
+    }
+}
diff --git a/algorithm/src/main/java/DP/MinimumTriangleTotal.java b/algorithm/src/main/java/DP/MinimumTriangleTotal.java
new file mode 100644
index 0000000..185903a
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinimumTriangleTotal.java
@@ -0,0 +1,52 @@
+package DP;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *  120 三角形最小路径和
+ */
+
+public class MinimumTriangleTotal {
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int res = 0;
+        int[][] memo = new int[triangle.size()][triangle.size()];
+        for(int[] t: memo){
+            Arrays.fill(t, 666);
+        }
+
+//        memo[0][0] = triangle.get(0).get(0);
+        res = dp(triangle.size()-1, triangle.size()-1, memo, triangle);
+        for(int i=0; i<memo.length; i++) {
+            res = Math.min(res, memo[memo.length-1][i]);
+        }
+        return res;
+    }
+
+    int dp(int row, int col, int[][] memo, List<List<Integer>> triangle) {
+        if(row<0 || col<0) {
+            return 0;
+        }
+
+        if(memo[row][col]!=666) {
+            return memo[row][col];
+        }
+
+        for(int i=0; i<=row; i++) {
+            // 处于最左侧
+            if (i == 0) {
+                memo[row][i] = dp(row-1, i, memo, triangle)+triangle.get(row).get(i);
+            } else if (i == row) {
+                // 处于最右侧
+                memo[row][i] = dp(row - 1, i-1, memo, triangle) + triangle.get(row).get(i);
+            } else {
+                // 取最小值
+                memo[row][i] = Math.min(
+                        dp(row - 1, i - 1, memo, triangle),
+                        dp(row - 1, i, memo, triangle)
+                ) + triangle.get(row).get(i);
+            }
+        }
+        return memo[row][col];
+    }
+}
diff --git a/algorithm/src/main/java/DP/MinimumTriangleTotalII.java b/algorithm/src/main/java/DP/MinimumTriangleTotalII.java
new file mode 100644
index 0000000..f24663b
--- /dev/null
+++ b/algorithm/src/main/java/DP/MinimumTriangleTotalII.java
@@ -0,0 +1,47 @@
+package DP;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *  120 三角形最小路径和（简化if判断语句）
+ */
+
+public class MinimumTriangleTotalII {
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int res = 0;
+        int[][] memo = new int[triangle.size()][triangle.size()];
+        for(int[] t: memo){
+            Arrays.fill(t, Integer.MAX_VALUE);
+        }
+
+        res = dp(triangle.size()-1, triangle.size()-1, memo, triangle);
+        for(int i=0; i<memo.length; i++) {
+            res = Math.min(res, memo[memo.length-1][i]);
+        }
+        return res;
+    }
+
+    int dp(int row, int col, int[][] memo, List<List<Integer>> triangle) {
+        if(row<0 || col<0) {
+            return 0;
+        }
+
+        if(memo[row][col]!=Integer.MAX_VALUE) {
+            return memo[row][col];
+        }
+
+
+        for(int i=0; i<=row; i++) {
+            int temp = dp(row-1, i, memo, triangle);
+            if(i>0) {
+                temp = Math.min(temp, dp(row-1, i-1, memo, triangle));
+            }
+            if(i+1<=row) {
+                temp = Math.min(temp, dp(row-1, i, memo, triangle));
+            }
+            memo[row][i] = temp+triangle.get(row).get(i);
+        }
+        return memo[row][col];
+    }
+}
diff --git a/algorithm/src/main/java/DP/PalindromeList.java b/algorithm/src/main/java/DP/PalindromeList.java
new file mode 100644
index 0000000..3eea95c
--- /dev/null
+++ b/algorithm/src/main/java/DP/PalindromeList.java
@@ -0,0 +1,65 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+
+/**
+ * 234. 回⽂链表
+ *
+ * 快慢指针
+ */
+
+
+public class PalindromeList {
+
+    public boolean palindrome(ListNode head) {
+        if(head==null) {
+            return true;
+        }
+        boolean res = true;
+        boolean even = false; // 默认为奇数
+
+        ListNode slow=head, fast=head;
+
+        // 首先获取中间节点，并判断个数的奇偶性
+        while(fast!=null && fast.next!=null) {
+            slow = slow.next;
+            if(fast.next.next==null) {
+                even = true;
+            }
+            fast = fast.next.next;
+        }
+
+        if(even) {
+            fast = slow;
+        }else {
+            fast = slow.next;
+        }
+
+        fast = reverse(fast);
+        slow = head;
+
+
+
+        // 判断是否为回文链表
+        while(fast!=null) {
+            if(slow.val!=fast.val) {
+                res = false;
+                break;
+            }
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        return res;
+    }
+
+    public ListNode reverse(ListNode head) {
+        if(head==null || head.next==null) {
+            return head;
+        }
+        ListNode last = reverse(head.next);
+        head.next.next = head;
+        head.next = null;
+        return last;
+    }
+}
diff --git a/algorithm/src/main/java/DP/ReverseNode.java b/algorithm/src/main/java/DP/ReverseNode.java
new file mode 100644
index 0000000..efd4b41
--- /dev/null
+++ b/algorithm/src/main/java/DP/ReverseNode.java
@@ -0,0 +1,18 @@
+package DP;
+
+// 反转链表
+
+import linkedList.doublePointer.ListNode;
+
+public class ReverseNode {
+
+    public ListNode reverseNode(ListNode list) {
+        if(list==null || list.next==null) {
+            return list;
+        }
+        ListNode last = reverseNode(list.next);
+        list.next.next = list;
+        list.next = null;
+        return last;
+    }
+}
diff --git a/algorithm/src/main/java/DP/ReverseNode2.java b/algorithm/src/main/java/DP/ReverseNode2.java
new file mode 100644
index 0000000..19702db
--- /dev/null
+++ b/algorithm/src/main/java/DP/ReverseNode2.java
@@ -0,0 +1,25 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+
+/**
+ *  对题目 [206. 反转链表]的扩展
+ * 反转链表前N个节点
+ */
+
+public class ReverseNode2 {
+
+    ListNode successor = null; // 后驱节点
+
+    public ListNode reverseNode(ListNode list, int n) {
+        if(list==null || list.next==null || n<=1) {
+            successor = list.next;
+            return list;
+        }
+        ListNode last = reverseNode(list.next, n-1);
+        list.next.next = list;
+        list.next = successor;
+
+        return last;
+    }
+}
diff --git a/algorithm/src/main/java/DP/ReverseNode3.java b/algorithm/src/main/java/DP/ReverseNode3.java
new file mode 100644
index 0000000..1f8d57b
--- /dev/null
+++ b/algorithm/src/main/java/DP/ReverseNode3.java
@@ -0,0 +1,36 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+
+public class ReverseNode3 {
+
+    private ListNode successor=null;
+
+    public ListNode reverseBetween(ListNode list, int m, int n) {
+        if(list==null || m<0 || n<0 || m>=n) {
+            return list;
+        }
+
+        ListNode p=list;
+        for(int i=0;i<m-1;i++) {
+            p = p.next;
+        }
+        ListNode last = reverse(p.next, n-m);
+        p.next = last;
+
+        return list;
+    }
+
+    public ListNode reverse(ListNode list, int n) {
+        if(list==null || list.next==null || n<=1) {
+            successor = list.next;
+            return list;
+        }
+
+        ListNode last = reverse(list.next, n-1);
+        list.next.next = list;
+        list.next = successor;
+
+        return last;
+    }
+}
diff --git a/algorithm/src/main/java/DP/ReverseNodeKGroup.java b/algorithm/src/main/java/DP/ReverseNodeKGroup.java
new file mode 100644
index 0000000..e2e4cfe
--- /dev/null
+++ b/algorithm/src/main/java/DP/ReverseNodeKGroup.java
@@ -0,0 +1,43 @@
+package DP;
+
+/**
+ * 25. K 个一组翻转链表
+ */
+
+import linkedList.doublePointer.ListNode;
+
+public class ReverseNodeKGroup {
+
+    public ListNode reverseNodeKGroup(ListNode list, int k) {
+        if(list == null) {
+            return null;
+        }
+        ListNode start=list, end=list;
+        for(int i=0;i<k;i++) {
+            // 不足 k 个，不需要反转，base case
+            if (end == null) {
+                return start;
+            }
+            end = end.next;
+        }
+
+        // 反转前 k 个元素
+        ListNode t = reverse(start, end);
+        start.next = reverseNodeKGroup(end, k);
+
+        return t;
+    }
+
+    // 反转区间内的链表，左闭右开 [a, b)
+    public ListNode reverse(ListNode a, ListNode b) {
+        if(a.next==b) {
+            return a;
+        }
+        ListNode last = reverse(a.next, b);
+        a.next.next = a;
+        a.next = null;
+
+        return last;
+    }
+
+}
diff --git a/algorithm/src/main/java/DP/RussianDollEnvelopes.java b/algorithm/src/main/java/DP/RussianDollEnvelopes.java
new file mode 100644
index 0000000..dcfbfea
--- /dev/null
+++ b/algorithm/src/main/java/DP/RussianDollEnvelopes.java
@@ -0,0 +1,45 @@
+package DP;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class RussianDollEnvelopes {
+
+    public int russianDollEnvelopes(int[][] envelopes) {
+        int[] memo = new int[envelopes.length];
+        memo[0] = 1;
+
+        // 排序
+        Arrays.sort(envelopes, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if(o1[0]==o2[0]) {
+                    return o1[1]-o2[1];
+                }else {
+                    return o2[1]-o1[1];
+                }
+            }
+        });
+
+//        dp(envelopes.length-1, envelopes, memo);
+
+        return memo[envelopes.length-1];
+    }
+
+//    int dp(int start, int[][] envelopes, int[] memo) {
+//        if(start==0) {
+//            return 1;
+//        }
+//
+//        if(envelopes[start][0]>envelopes[start-1][0] && envelopes[start][1]>envelopes[start-1][1]) {
+//            if(memo[start-1]==0) {
+//                memo[start-1] = dp(start-1, envelopes, memo);
+//            }
+//            memo[start]=memo[start-1]+1;
+//        }else{
+////            dp
+//        }
+//    }
+
+
+}
diff --git a/algorithm/src/main/java/DP/UniquePathsWithObstacles.java b/algorithm/src/main/java/DP/UniquePathsWithObstacles.java
new file mode 100644
index 0000000..3f31ce9
--- /dev/null
+++ b/algorithm/src/main/java/DP/UniquePathsWithObstacles.java
@@ -0,0 +1,53 @@
+package DP;
+
+import java.util.Arrays;
+
+/**
+ * 63 不同路径II
+ */
+
+public class UniquePathsWithObstacles {
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        int res = 0;
+        int[][] memo = new int[obstacleGrid.length][obstacleGrid[0].length];
+        for(int[] ints:memo) {
+            Arrays.fill(ints, -1);
+        }
+        if(obstacleGrid[0][0]==0) {
+            memo[0][0] = 1;
+        }else{
+            memo[0][0] = 0;
+        }
+//        if(memo.length>1){
+//            if(obstacleGrid[1][0]==0 && memo[0][0]==1) {
+//                memo[1][0] = 1;
+//            }else {
+//                memo[1][0] = 0;
+//            }
+//        }
+//        if(memo[0].length>1){
+//            if(obstacleGrid[0][1]==0 && memo[0][0]==1) {
+//                memo[0][1] = 1;
+//            }else {
+//                memo[0][1] = 0;
+//            }
+//        }
+        res = dp(memo.length-1, memo[0].length-1, memo, obstacleGrid);
+
+
+        return res;
+    }
+
+    int dp(int row, int col, int[][] memo, int[][] obs){
+        if(row<0 || col<0 || obs[row][col]==1) {
+            return 0;
+        }
+
+        if(memo[row][col]!=-1) {
+            return memo[row][col];
+        }
+
+        memo[row][col] = dp(row-1, col,memo, obs) + dp(row, col-1, memo, obs);
+        return memo[row][col];
+    }
+}
diff --git a/algorithm/src/main/java/alibaba/DuplicateLength.java b/algorithm/src/main/java/alibaba/DuplicateLength.java
new file mode 100644
index 0000000..003d282
--- /dev/null
+++ b/algorithm/src/main/java/alibaba/DuplicateLength.java
@@ -0,0 +1,30 @@
+package alibaba;
+
+import java.util.HashMap;
+
+public class DuplicateLength {
+
+    int duplicateLength(String str) {
+        int res = -1;
+
+        HashMap<Character, Integer> map = new HashMap<>();
+        int pos=0;
+
+        // 移动位置
+        while(pos<str.length()) {
+            char c = str.charAt(pos);
+
+            if(map.containsKey(c)) {
+                res = Math.max(res, pos-map.get(c)-1);
+                map.replace(c, pos);
+            } else {
+                map.put(c, pos);
+            }
+            pos++;
+        }
+
+
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/alibaba/ThreadPrintABC.java b/algorithm/src/main/java/alibaba/ThreadPrintABC.java
new file mode 100644
index 0000000..988131d
--- /dev/null
+++ b/algorithm/src/main/java/alibaba/ThreadPrintABC.java
@@ -0,0 +1,55 @@
+package alibaba;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+
+public class ThreadPrintABC {
+    int state = 0;
+    int line = 10;
+    int size = 3;
+    ReentrantLock lock = new ReentrantLock();
+
+    public ThreadPrintABC(int size, int line) {
+        this.size = size;
+        this.line = line;
+    }
+
+    public void printABC(String s, int num) {
+        while(true) {
+            lock.lock();
+            if (state%size == num) {
+                System.out.print(s);
+                state+=1;
+                if(state%line==0) {
+                    System.out.println();
+                }else if(state%size==0) {
+                    System.out.print(" ");
+                }
+            }
+            lock.unlock();
+        }
+    }
+
+
+    public static void main(String[] args) {
+        ThreadPrintABC p = new ThreadPrintABC(3, 30);
+        Thread thread1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                p.printABC("A", 0);
+            }
+        });
+
+        Thread thread2 = new Thread(() -> {
+            p.printABC("B", 1);
+        });
+
+        Thread thread3 = new Thread(() -> {
+            p.printABC("C", 2);
+        });
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/alibaba/ThreadPrintABC2.java b/algorithm/src/main/java/alibaba/ThreadPrintABC2.java
new file mode 100644
index 0000000..dc7e9fb
--- /dev/null
+++ b/algorithm/src/main/java/alibaba/ThreadPrintABC2.java
@@ -0,0 +1,48 @@
+package alibaba;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ThreadPrintABC2 {
+    int size;
+    int state;
+    int count;
+
+    ReentrantLock lock = new ReentrantLock();
+
+    public ThreadPrintABC2(int size, int group) {
+        this.size = size;
+        this.count = size*group;
+    }
+
+    public void printABC(String s, int nums, int val) {
+        while(state<count) {
+            lock.lock();
+            if(state%size==val && state<count) {
+                for(int i=0;i<nums; i++) {
+                    System.out.print(s);
+                }
+                state++;
+                if(state%size==0) {
+                    System.out.println();
+                }
+            }
+            lock.unlock();
+        }
+    }
+
+    public static void main(String[] args) {
+        ThreadPrintABC2 p = new ThreadPrintABC2(3, 10);
+
+        new Thread(() -> {
+            p.printABC("AA", 1, 0);
+        }).start();
+
+        new Thread(() -> {
+            p.printABC("BB", 2, 1);
+        }).start();
+
+        new Thread(() -> {
+            p.printABC("CC", 3, 2);
+        }).start();
+    }
+}
diff --git a/algorithm/src/main/java/alibaba/ThreadPrintCharNum.java b/algorithm/src/main/java/alibaba/ThreadPrintCharNum.java
new file mode 100644
index 0000000..15ec719
--- /dev/null
+++ b/algorithm/src/main/java/alibaba/ThreadPrintCharNum.java
@@ -0,0 +1,56 @@
+package alibaba;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ThreadPrintCharNum {
+    int size;
+    int count;
+    int state;
+    int n=1;
+    char c = 'A';
+    ReentrantLock lock = new ReentrantLock();
+
+    public ThreadPrintCharNum(int size, int group) {
+        this.size = size;
+        this.count = size*group;
+    }
+
+    public void printNum(int val) {
+        while (state<count) {
+            lock.lock();
+            if(state<count && state%size==val) {
+                System.out.print(n);
+                state++;
+                n+=1;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void printChar(int val) {
+        while(state<count) {
+            lock.lock();
+            if(state<count &&state%size==val) {
+                System.out.print(c);
+                c+=1;
+                state++;
+            }
+            lock.unlock();
+        }
+    }
+
+    public static void main(String[] args) {
+
+        ThreadPrintCharNum p = new ThreadPrintCharNum(2, 26);
+
+        new Thread(() ->
+                p.printNum(0)
+        ).start();
+
+
+        new Thread(() -> {
+            p.printChar(1);
+        }).start();
+
+    }
+}
diff --git a/algorithm/src/main/java/alibaba/ThreadPrintNums.java b/algorithm/src/main/java/alibaba/ThreadPrintNums.java
new file mode 100644
index 0000000..8506ee9
--- /dev/null
+++ b/algorithm/src/main/java/alibaba/ThreadPrintNums.java
@@ -0,0 +1,46 @@
+package alibaba;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ThreadPrintNums {
+    int size;
+    int state;
+    ReentrantLock lock = new ReentrantLock();
+
+    public ThreadPrintNums(int nums) {
+        this.size = size;
+    }
+
+    void printNum(int val) {
+        while (state <= 100) {
+            lock.lock();
+            if(state<=100 && state%2==val) {
+                System.out.println(state);
+                state += 1;
+            }
+            lock.unlock();
+        }
+    }
+
+
+    public static void main(String[] args) {
+        ThreadPrintNums p = new ThreadPrintNums(100);
+
+        // 打印奇数
+        new Thread(
+                () -> {
+                    p.printNum(0);
+                }
+        ).start();
+
+        // 打印偶数
+        new Thread(
+                () -> {
+                    p.printNum(1);
+                }
+        ).start();
+
+
+    }
+}
+
diff --git a/algorithm/src/main/java/array/binarySearch/EatBanana.java b/algorithm/src/main/java/array/binarySearch/EatBanana.java
new file mode 100644
index 0000000..8ed88e4
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/EatBanana.java
@@ -0,0 +1,55 @@
+package array.binarySearch;
+
+public class EatBanana {
+
+    public int eatBanana(int[] piles, int hour) {
+        if(piles.length==0) {
+            return -1;
+        }
+        if(piles.length==1) {
+            return (piles[0]+hour-1)/hour;
+        }
+
+        int sum = 0;
+        for(int t: piles) {
+            sum += t;
+        }
+
+        int left = sum/hour;
+        int right = sum;
+        while(left<=right) {
+            int mid = (left+right)>>1;
+            int h = calHour(piles, mid);
+            if(h==hour) {
+                left=mid;
+                break;
+            }else if(h<hour) {
+                right = mid;
+            }else{
+                left = mid+1;
+            }
+        }
+
+        // 左边界处理
+        while(left>0) {
+            if(calHour(piles, left-1)<=hour) {
+                left-=1;
+            }else {
+                break;
+            }
+        }
+
+        return left;
+    }
+
+    private int calHour(int[] piles, int speed) {
+        int hour = 0;
+        for(int i=0;i<piles.length;i++) {
+            hour += piles[i]/speed;
+            if(piles[i]%speed>0) {
+                hour += 1;
+            }
+        }
+        return hour;
+    }
+}
diff --git a/algorithm/src/main/java/array/binarySearch/IsSubsequence.java b/algorithm/src/main/java/array/binarySearch/IsSubsequence.java
new file mode 100644
index 0000000..37bd4ba
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/IsSubsequence.java
@@ -0,0 +1,29 @@
+package array.binarySearch;
+
+/**
+ * 392.判断子序列
+ */
+
+public class IsSubsequence {
+
+    boolean isSubsequence(String s, String t) {
+
+        boolean res = false;
+
+        int left = 0;
+        int right = 0;
+        while (left<s.length() && right<t.length()) {
+            if(s.charAt(left)==t.charAt(right)) {
+                left++;
+                right++;
+            }else{
+                right++;
+            }
+        }
+        if(left==s.length()) {
+            res = true;
+        }
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/array/binarySearch/PeakArray.java b/algorithm/src/main/java/array/binarySearch/PeakArray.java
new file mode 100644
index 0000000..3e968a9
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/PeakArray.java
@@ -0,0 +1,42 @@
+package array.binarySearch;
+
+/**
+ * 852. ⼭脉数组的峰顶索引
+ */
+
+public class PeakArray {
+
+//    public int peakArray(int[] nums) {
+//        if(nums.length<3) {
+//            return -1;
+//        }
+//        int low=0, high=nums.length-1;
+//        int mid=-1;
+//        while(low<high) {
+//            mid = (low+high) >> 1;
+//            if(nums[mid]<nums[mid+1]) {
+//                low = mid+1;
+//            }else {
+//                high = mid;
+//            }
+//        }
+//        return low;
+//    }
+
+    public int peakArray(int[] nums) {
+        if(nums.length<3) {
+            return -1;
+        }
+        int left=0, right=nums.length-1;
+        while(left<right) {
+            int mid = (left+right)>>1;
+            if(nums[mid]<nums[mid+1]) {
+                left = mid+1;
+            }else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+
+}
diff --git a/algorithm/src/main/java/array/binarySearch/PreimageSizeZF.java b/algorithm/src/main/java/array/binarySearch/PreimageSizeZF.java
new file mode 100644
index 0000000..8916842
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/PreimageSizeZF.java
@@ -0,0 +1,51 @@
+package array.binarySearch;
+
+/**
+ * 793. 阶乘函数后 K 个零
+ * 如果存在解，那么个数一定是5个
+ * 如果不存在解，那么返回0
+ */
+
+public class PreimageSizeZF {
+
+
+    /**
+     * 使用框架写法
+     */
+    int preimageSizeZF(long k) {
+        int res=0;
+        // 这里的左值和右值设定需要数学知识，这里不阐述，详情看
+        // https://leetcode.cn/problems/preimage-size-of-factorial-zeroes-function/solution/jie-cheng-han-shu-hou-kge-ling-by-leetcode/
+
+        // 确定边界
+        long left = 4*k;
+        long right = 4*k+5;
+        boolean found = false;
+        while(left<right) {
+            long mid = (left+right)>>1;
+            long sz = tailingZeros(mid);
+            if(sz==k) {
+                found = true;
+                break;
+            }else if(k>sz) {
+                left = mid+1;
+            }else {
+                right = mid;
+            }
+        }
+        if(found) {
+            res = 5;
+        }
+        return res;
+    }
+
+    private long tailingZeros(long n) {
+        long divisor=5;
+        long res=0;
+        while(n>=divisor) {
+            res += n/divisor;
+            divisor*=5;
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/array/binarySearch/SearchInsertPosition.java b/algorithm/src/main/java/array/binarySearch/SearchInsertPosition.java
new file mode 100644
index 0000000..1b01a13
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/SearchInsertPosition.java
@@ -0,0 +1,71 @@
+package array.binarySearch;
+
+/**
+ * 35. 搜索插⼊位置
+ */
+
+public class SearchInsertPosition {
+
+    /**
+     * 最初写法
+     */
+//    public int searchInsert(int[] nums, int target) {
+//        // 处理边界问题
+//        if(nums.length==0 || nums[0]>target) {
+//            return 0;
+//        }
+//        if(nums[nums.length-1]<target) {
+//            return nums.length;
+//        }
+
+//        int low=0, high=nums.length-1;
+//        int mid=0;
+//        while(low<high) {
+//             mid = (low+high)>>1;
+//            if(nums[mid]>target) {
+//                high = mid-1;
+//            }else if(nums[mid]<target) {
+//                low = mid+1;
+//            }else {
+//                while(mid>0 && nums[mid-1]==target) {
+//                    mid--;
+//                }
+//                return mid;
+//            }
+//        }
+//        return mid;
+//    }
+
+    /**
+     * 按照模板写法
+     */
+    public int searchInsert(int[] nums, int target) {
+        // 对参数进行处理
+        if(nums.length==0 || nums[0]>target) {
+            return 0;
+        }
+        if(nums[nums.length-1]<target) {
+            return nums.length;
+        }
+
+        int left=0, right=nums.length-1;
+
+        while(left<right) {
+            int mid=0;
+             mid = (left+right)>>1;
+            if(nums[mid]<target) {
+                left = mid+1;
+            }else {
+                right = mid;
+            }
+        }
+
+        // 对结果进行处理
+        while(left>0 && nums[left-1]==target) {
+            left--;
+        }
+        return left;
+    }
+
+
+}
diff --git a/algorithm/src/main/java/array/binarySearch/SearchMatrix.java b/algorithm/src/main/java/array/binarySearch/SearchMatrix.java
new file mode 100644
index 0000000..44ff2c7
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/SearchMatrix.java
@@ -0,0 +1,88 @@
+package array.binarySearch;
+
+/**
+ * 74. 搜索⼆维矩阵
+ */
+
+public class SearchMatrix {
+
+    /**
+     * 最初算法
+     */
+//    public boolean searchMatrix(int[][] nums, int target) {
+//
+//        if(nums.length==0 || nums[0].length==0) {
+//            return false;
+//        }
+//
+//        if(nums[0][0]>target || nums[nums.length-1][nums[0].length-1]<target) {
+//            return false;
+//        }
+//
+//        if(nums[nums.length-1][nums[0].length-1]==target) {
+//            return true;
+//        }
+//
+//        int M = nums.length;
+//        int N = nums[0].length;
+//        boolean res=false;
+//        int low, high, mid=0;
+//        low = 0;
+//        high = M*N-1;
+//
+//        while(low<high) {
+//            mid = (low+high)>>1;
+//            int m = mid/N;
+//            int n = mid%N;
+//            if(nums[m][n]<target) {
+//                low = mid+1;
+//            }else if(nums[m][n]>target) {
+//                high = mid-1;
+//            }else {
+//                res = true;
+//                break;
+//            }
+//        }
+//        if(low==high && nums[low/N][low%N]==target) {
+//            res = true;
+//        }
+//        return res;
+//    }
+
+    /**
+     * 使用框架算法
+     */
+    public boolean searchMatrix(int[][] nums, int target) {
+
+        // 参数处理
+        if(nums.length==0 || nums[0].length==0) {
+            return false;
+        }
+        if(nums[0][0]>target || nums[nums.length-1][nums[0].length-1]<target) {
+            return false;
+        }
+        if(nums[nums.length-1][nums[0].length-1]==target) {
+            return true;
+        }
+
+        int M = nums.length;
+        int N = nums[0].length;
+        int left=0, right=M*N-1;
+
+        while(left<right) {
+            int mid = (left+right)>>1;
+            int m = mid/N;
+            int n = mid%N;
+            if(nums[m][n]<target) {
+                left = mid+1;
+            }else{
+                right = mid;
+            }
+        }
+
+        if(nums[left/N][left%N]==target) {
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/algorithm/src/main/java/array/binarySearch/SearchPosition.java b/algorithm/src/main/java/array/binarySearch/SearchPosition.java
new file mode 100644
index 0000000..af49011
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/SearchPosition.java
@@ -0,0 +1,33 @@
+package array.binarySearch;
+
+/**
+ * 704. ⼆分查找
+ * 难度:简单
+ * 解题：略
+ */
+
+public class SearchPosition {
+
+    public int search(int[] nums, int target) {
+        // 异常的处理
+        if(nums.length<1) {
+            return -1;
+        }
+
+        int left=0, right=nums.length-1;
+        while(left<right) {
+            int mid = (left+right) >> 1;
+            if(nums[mid]<target) {
+                left = mid+1;
+            }else {
+                right = mid;
+            }
+        }
+        // 异常情况的处理
+        if (nums[left]!=target)
+            return -1;
+
+
+        return left;
+    }
+}
diff --git a/algorithm/src/main/java/array/binarySearch/SearchRange.java b/algorithm/src/main/java/array/binarySearch/SearchRange.java
new file mode 100644
index 0000000..c894d30
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/SearchRange.java
@@ -0,0 +1,53 @@
+package array.binarySearch;
+
+/**
+ * 34. 在排序数组中查找元素的第⼀个和最后⼀个位置
+ */
+public class SearchRange {
+
+    public int[] searchRange(int[] nums, int target) {
+        /**
+         * 给定值target，查询在有序数组中的位置
+         */
+
+        int[] res = new int[] {-1,-1};
+        int low,mid, high;
+        boolean rangeFound;
+        rangeFound = false;
+        low = 0;
+        high = nums.length-1;
+
+        while(low<high) {
+            if(rangeFound) {
+                return res;
+            }
+            mid = (low+high)>>1;
+            if(nums[mid]<target) {
+                low = mid+1;
+            }else if(nums[mid]>target) {
+                high = mid-1;
+            }else {
+                // 找到目标值
+                int tLeft = mid;
+                int tRight = mid;
+                // 向左边遍历，取左边界
+                while(tLeft>0 && nums[tLeft-1]==target) {
+                    tLeft--;
+                }
+
+                // 向右边遍历，取右边界
+                while(tRight+1<nums.length && nums[tRight+1]==target) {
+                    tRight++;
+                }
+
+
+                res[0] = tLeft;
+                res[1] = tRight;
+                rangeFound = true;
+            }
+        }
+
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/array/binarySearch/ShipWithinDays.java b/algorithm/src/main/java/array/binarySearch/ShipWithinDays.java
new file mode 100644
index 0000000..c610e31
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/ShipWithinDays.java
@@ -0,0 +1,48 @@
+package array.binarySearch;
+
+/**
+ * 1011. 在 D 天内送达包裹的能⼒
+ */
+
+public class ShipWithinDays {
+
+    public int shipWithinDays(int[] nums, int days) {
+        int left = 0, right = 0;
+        for (int var : nums) {
+            left = Math.max(left, var);
+            right += var;
+        }
+
+        while (left < right) {
+            int mid = (left + right) >> 1;
+            if (calDays(nums, mid)>days) {
+                left = mid+1;
+
+            }else {
+                right=mid;
+            }
+        }
+        return left;
+    }
+
+    private int calDays(int[] nums, int target) {
+        int index = 0;
+        int days = 0;
+
+        while (index < nums.length) {
+            int sum = 0;
+            while (index<nums.length) {
+                sum += nums[index];
+                if(sum <= target)
+                    index++;
+                else
+                    break;;
+            }
+            days++;
+        }
+//        System.out.println(target+"  "+days);
+        return days;
+
+    }
+
+}
diff --git a/algorithm/src/main/java/array/binarySearch/TailingZeros.java b/algorithm/src/main/java/array/binarySearch/TailingZeros.java
new file mode 100644
index 0000000..3ad45c6
--- /dev/null
+++ b/algorithm/src/main/java/array/binarySearch/TailingZeros.java
@@ -0,0 +1,20 @@
+package array.binarySearch;
+
+/**
+ * 793. 阶乘函数后 K 个零
+ * 解题思路：https://labuladong.github.io/algo/4/32/115/
+ * 将问题转换成：n!可以分解成多少个因子5
+ */
+
+public class TailingZeros {
+
+    public int tailingZeros(int n) {
+        int m=5;
+        int res = 0;
+        while(n>=m) {
+            res += n/m;
+            m*=5;
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/array/other/AdvantageShuffle.java b/algorithm/src/main/java/array/other/AdvantageShuffle.java
new file mode 100644
index 0000000..5028f5f
--- /dev/null
+++ b/algorithm/src/main/java/array/other/AdvantageShuffle.java
@@ -0,0 +1,49 @@
+package array.other;
+
+import java.util.*;
+
+/**
+ *  870 优势洗牌
+ */
+
+public class AdvantageShuffle {
+
+    public int[] advantageShuffle(int[] nums1, int[] nums2) {
+        int[] res = new int[nums1.length];
+        PriorityQueue<ArrayList<Integer>> queue = new PriorityQueue<>(
+                (ArrayList<Integer>t1, ArrayList<Integer>t2) -> {
+                    // 从大到小排序
+                    return t2.get(1)-t1.get(1);
+                }
+        );
+        for(int i=0; i<nums2.length; i++) {
+            ArrayList<Integer> arr = new ArrayList<>();
+            arr.add(i);
+            arr.add(nums2[i]);
+            queue.add(arr);
+        }
+
+        Arrays.sort(nums1);
+
+        int left = 0, right = nums1.length-1;
+
+
+        while(left<=right) {
+            // 获取nums2的最大值
+            ArrayList<Integer> arr = queue.poll();
+            assert arr != null;
+            int index = arr.get(0);
+            int value = arr.get(1);
+
+            if(nums1[right]>value) {
+                res[index] = nums1[right];
+                right--;
+            }else{
+                res[index] = nums1[left];
+                left++;
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/array/other/ContainerWithMostWater.java b/algorithm/src/main/java/array/other/ContainerWithMostWater.java
new file mode 100644
index 0000000..cf0b806
--- /dev/null
+++ b/algorithm/src/main/java/array/other/ContainerWithMostWater.java
@@ -0,0 +1,33 @@
+package array.other;
+
+/**
+ * 11 盛最多水的容器
+ */
+
+public class ContainerWithMostWater {
+
+    int containerWithMOstWater(int[] nums) {
+        int res = 0;
+        if(nums.length<2) {
+            return res;
+        }
+
+        int left=0, right=nums.length-1;
+        while (left<right) {
+            int capacity = waterCapacity(left, right, nums);
+            res = Math.max(res, capacity);
+            if(nums[left]<=nums[right]) {
+                left++;
+            }else{
+                right--;
+            }
+        }
+
+        return res;
+
+    }
+
+    int waterCapacity(int left, int right, int[] nums) {
+        return Math.min(nums[left], nums[right]) * (right-left);
+    }
+}
diff --git a/algorithm/src/main/java/array/other/IntervalListIntersections.java b/algorithm/src/main/java/array/other/IntervalListIntersections.java
new file mode 100644
index 0000000..e5cce75
--- /dev/null
+++ b/algorithm/src/main/java/array/other/IntervalListIntersections.java
@@ -0,0 +1,35 @@
+package array.other;
+
+import java.util.ArrayList;
+
+/**
+ *  986 区间列表的交集
+ */
+
+public class IntervalListIntersections {
+
+    ArrayList<ArrayList<Integer>> intervalListIntersections(int[][] nums1, int[][] nums2){
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+        int left=0, right=0;
+        while (left<nums1.length && right<nums2.length) {
+            // nums1[left][0] 在 nums2[right]范围内 或 nums1[left][1] 在 nums2[right]范围内
+            if((nums2[right][0]<= nums1[left][0] &&  nums1[left][0]<=nums2[right][1]) ||
+                    (nums2[right][0]<=nums1[left][1] && nums1[left][1]<=nums2[right][1])) {
+                int leftBound = Math.max(nums1[left][0], nums2[right][0]);
+                int rightBound = Math.min(nums1[left][1], nums2[right][1]);
+                ArrayList<Integer> arr = new ArrayList<>();
+                arr.add(leftBound);
+                arr.add(rightBound);
+                res.add(arr);
+            }
+            if(nums1[left][1]<= nums2[right][1]) {
+                left++;
+            } else if(nums1[left][1]> nums2[right][1]) {
+                right++;
+            }
+        }
+
+        return res;
+
+    }
+}
diff --git a/algorithm/src/main/java/array/other/MaxRepeatSubString.java b/algorithm/src/main/java/array/other/MaxRepeatSubString.java
new file mode 100644
index 0000000..7ab144f
--- /dev/null
+++ b/algorithm/src/main/java/array/other/MaxRepeatSubString.java
@@ -0,0 +1,33 @@
+package array.other;
+
+/**
+ *  1668 最大重复子字符串
+ */
+
+public class MaxRepeatSubString {
+    public int maxRepeating(String sequence, String word) {
+        int res = 0;
+        int pos=0, p1=0, p2=0;
+        while(pos<sequence.length()) {
+            res = Math.max(numberOfSubstring(sequence, word, pos), res);
+            pos++;
+        }
+
+        return res;
+
+    }
+
+    int numberOfSubstring(String sequence, String word, int p1){
+        int res = 0;
+        for(int i=p1; i<=sequence.length()-word.length(); i+=word.length()){
+            for(int j=0; j<word.length();j++) {
+                if (sequence.charAt(i+j) != word.charAt(j)) {
+                    return res;
+                }
+            }
+            res++;
+        }
+
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/array/other/RemoveDuplicateSortedArray.java b/algorithm/src/main/java/array/other/RemoveDuplicateSortedArray.java
new file mode 100644
index 0000000..c4c76db
--- /dev/null
+++ b/algorithm/src/main/java/array/other/RemoveDuplicateSortedArray.java
@@ -0,0 +1,29 @@
+package array.other;
+
+/**
+ * 26 删除有序数组中的重复项
+ */
+
+public class RemoveDuplicateSortedArray {
+
+    public void removeDuplicateSortedArray(int[] nums){
+        // 若数组的长度小于2，那么不用处理
+        if(nums.length<2) {
+            return;
+        }
+
+        int left=0, right=1;
+        while(right<nums.length) {
+            if(nums[left]!=nums[right]) {
+                left++;
+                nums[left]=nums[right];
+            }
+            right++;
+        }
+
+        // 对于left右侧的数据均置为0
+        for(int i=left+1; i<right;i++) {
+            nums[i] = 0;
+        }
+    }
+}
diff --git a/algorithm/src/main/java/array/other/Search2DMatrixII.java b/algorithm/src/main/java/array/other/Search2DMatrixII.java
new file mode 100644
index 0000000..274bdff
--- /dev/null
+++ b/algorithm/src/main/java/array/other/Search2DMatrixII.java
@@ -0,0 +1,26 @@
+package array.other;
+
+/**
+ *  240. 搜索二维矩阵II
+ */
+
+public class Search2DMatrixII {
+
+    public boolean search2DMatrixII(int[][] nums, int target) {
+        boolean res = false;
+        int i=0, j=nums[0].length-1;
+        while(i<nums.length && j>=0) {
+            if(nums[i][j]==target) {
+                res = true;
+                break;
+            } else if(nums[i][j]>target) {
+                j--;
+            } else {
+                i++;
+            }
+
+        }
+        return res;
+
+    }
+}
diff --git a/algorithm/src/main/java/array/other/SquaresSortedArray.java b/algorithm/src/main/java/array/other/SquaresSortedArray.java
new file mode 100644
index 0000000..be52187
--- /dev/null
+++ b/algorithm/src/main/java/array/other/SquaresSortedArray.java
@@ -0,0 +1,27 @@
+package array.other;
+
+/**
+ * 977 有序数组的平方
+ */
+
+public class SquaresSortedArray {
+
+    int[] squaresSortedArray(int[] nums) {
+        int[] res = new int[nums.length];
+        int left=0, right=nums.length-1, index=nums.length-1;
+
+        while (left<=right){
+            if(Math.abs(nums[left])>Math.abs(nums[right])) {
+                res[index] = nums[left]*nums[left];
+                index--;
+                left++;
+            }else{
+                res[index] = nums[right]*nums[right];
+                index--;
+                right--;
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/array/other/TrappingRainWater.java b/algorithm/src/main/java/array/other/TrappingRainWater.java
new file mode 100644
index 0000000..ed02766
--- /dev/null
+++ b/algorithm/src/main/java/array/other/TrappingRainWater.java
@@ -0,0 +1,45 @@
+package array.other;
+
+import java.util.PriorityQueue;
+import java.util.Stack;
+
+/**
+ *  42 接雨水
+ */
+
+public class TrappingRainWater {
+
+    int trappingRainWater(int[] nums) {
+        int res = 0;
+        if(nums.length<2) {
+            return res;
+        }
+
+        int[] leftHeight = new int[nums.length];
+        int[] rightHeight = new int[nums.length];
+        for(int i=0;i<nums.length;i++) {
+            if(i==0) {
+                leftHeight[i] = nums[i];
+            } else {
+                leftHeight[i] = Math.max(nums[i], leftHeight[i-1]);
+            }
+        }
+
+        for(int i=nums.length-1; i>=0;i--) {
+            if(i==nums.length-1) {
+                rightHeight[i] = nums[i];
+            } else {
+                rightHeight[i] = Math.max(nums[i], rightHeight[i+1]);
+            }
+        }
+        
+        for(int i=0; i<nums.length;i++) {
+            int height = Math.min(leftHeight[i], rightHeight[i]);
+            res = res + (height-nums[i]);
+        }
+
+
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/array/other/TwoSumLessThanK.java b/algorithm/src/main/java/array/other/TwoSumLessThanK.java
new file mode 100644
index 0000000..5878efe
--- /dev/null
+++ b/algorithm/src/main/java/array/other/TwoSumLessThanK.java
@@ -0,0 +1,30 @@
+package array.other;
+
+import java.util.Arrays;
+
+/**
+ * 1099 小于K的两数之和
+ */
+
+public class TwoSumLessThanK {
+
+    public int twoSumLessThanK(int[] nums, int k) {
+        int res = -1;
+        // 对数组排序
+        Arrays.sort(nums);
+
+        int left = 0, right=nums.length-1;
+
+        while(left<right) {
+            int temp = nums[left]+nums[right];
+            if(temp<k) {
+                res = Math.max(res, temp);
+                left++;
+            }else{
+                right--;
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/array/slideWindow/FindAnagrams.java b/algorithm/src/main/java/array/slideWindow/FindAnagrams.java
new file mode 100644
index 0000000..995cfad
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/FindAnagrams.java
@@ -0,0 +1,53 @@
+package array.slideWindow;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * 438. 找到字符串中所有字⺟异位词
+ */
+
+public class FindAnagrams{
+
+    public ArrayList<Integer> findAnagrams(String s, String p) {
+        HashMap<Character, Integer> map = new HashMap<>();
+        HashMap<Character, Integer> need = new HashMap<>();
+        int count=0;
+
+        // 对need进行初始化
+        for(int i=0;i<p.length();i++) {
+            char c = p.charAt(i);
+            need.put(c, need.getOrDefault(c, 0)+1);
+        }
+
+        ArrayList<Integer> res = new ArrayList<>();
+        int left = 0, right=0;
+        while(right<s.length()) {
+            char c = s.charAt(right);
+
+            // 进行窗口数据更新
+            map.put(c, map.getOrDefault(c,0)+1);
+            right++;
+            if(map.getOrDefault(c, 0).equals(need.getOrDefault(c, 0))) {
+                count++;
+            }
+            while(right-left>=p.length()) {
+
+                // 进行窗口数据更新
+                if(count==p.length()) {
+                    res.add(left);
+                }
+                char t = s.charAt(left);
+                if(map.get(t).equals(need.getOrDefault(t, 0))) {
+                    count--;
+                }
+                map.replace(t, map.get(t)-1);
+                left++;
+            }
+
+        }
+
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/array/slideWindow/LengthOfLongestSubstring.java b/algorithm/src/main/java/array/slideWindow/LengthOfLongestSubstring.java
new file mode 100644
index 0000000..97a3401
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/LengthOfLongestSubstring.java
@@ -0,0 +1,30 @@
+package array.slideWindow;
+
+import java.util.HashMap;
+
+
+public class LengthOfLongestSubstring {
+
+    public int lengthOfLongestSubstring(String s) {
+        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
+
+        int res=0;
+        int left=0, right=0;
+        while(right<s.length()) {
+            char key = s.charAt(right);
+            // 若key不存在，则创建该key值，并设置默认value值为0
+            map.put(key, map.getOrDefault(key,0)+1);
+            right++;
+            // 左侧窗口是否收缩
+            while(map.get(key)>1) {
+                char temp = s.charAt(left);
+                map.replace(temp,map.get(temp)-1);
+                left++;
+            }
+            res = Math.max(res, right-left);
+        }
+
+        return res;
+
+    }
+}
diff --git a/algorithm/src/main/java/array/slideWindow/MinWindowSubstring.java b/algorithm/src/main/java/array/slideWindow/MinWindowSubstring.java
new file mode 100644
index 0000000..0b8be00
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/MinWindowSubstring.java
@@ -0,0 +1,57 @@
+package array.slideWindow;
+
+/**
+ * 76. 最⼩覆盖⼦串
+ */
+
+import java.util.HashMap;
+
+public class MinWindowSubstring {
+
+    public String minWindowSubstring(String s, String t) {
+        HashMap<Character, Integer> map = new HashMap<>();
+        HashMap<Character, Integer> need = new HashMap<>();
+
+        // 对参数进行处理
+        for(int i=0; i<t.length(); i++) {
+            char c = t.charAt(i);
+            need.put(c, need.getOrDefault(c, 0)+1);
+        }
+
+        int left=0, right=0;
+        int count=0;
+        String res="";
+        int tleft=-1,tright=s.length();
+
+        // 扩张
+        while(right<s.length()) {
+            char c = s.charAt(right);
+            right++;
+            map.put(c, map.getOrDefault(c, 0)+1);
+            if(map.get(c).equals(need.getOrDefault(c, 0))) {
+                count++;
+            }
+
+            // 收缩
+            while(count==need.size()) {
+                if(tright-tleft > right-left) {
+                    tleft = left;
+                    tright = right;
+                }
+
+                char tt = s.charAt(left);
+                left++;
+                if(map.get(tt).equals(need.getOrDefault(tt,0))) {
+                    count--;
+                }
+                map.replace(tt, map.get(tt)-1);
+            }
+        }
+
+        if(tleft<0) {
+            return "";
+        }else {
+            return s.substring(tleft, tright);
+        }
+    }
+}
diff --git a/algorithm/src/main/java/array/slideWindow/MinimumWindow.java b/algorithm/src/main/java/array/slideWindow/MinimumWindow.java
new file mode 100644
index 0000000..4863801
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/MinimumWindow.java
@@ -0,0 +1,60 @@
+package array.slideWindow;
+
+import java.util.LinkedList;
+
+// 这是对 [239. 滑动窗⼝最⼤值] 的改编，求最小值
+
+public class MinimumWindow {
+
+    // 使用单调队列求解，时间复杂度为O(N)
+    public int[] minimumWindow(int[] nums, int k) {
+        if (k < 1 || nums.length < k) {
+            return new int[]{};
+        }
+
+        MonotonicMinQueue window = new MonotonicMinQueue();
+        int[] res = new int[nums.length+1-k];
+
+        for(int i=0;i<nums.length;i++) {
+            if(i<k-1) {
+                // 先填满窗口的前 k - 1
+                window.push(nums[i]);
+            }else {
+                window.push(nums[i]);
+                res[i+1-k]=window.min();
+                // 移除最左侧数据
+                window.pop(nums[i+1-k]);
+            }
+        }
+        return res;
+    }
+
+
+}
+
+/* 单调队列的实现 */
+class MonotonicMinQueue {
+    // 队列的第一个值最大，后面的值按照添加顺序排列
+    LinkedList<Integer> minq = new LinkedList<Integer>();
+
+    public void push(int n) {
+        // 将大于 n 的元素全部删除(等于时保留)
+        while(!minq.isEmpty() && minq.getLast()>n) {
+            minq.pollLast();
+        }
+        // 然后将 n 加入尾部
+        minq.addLast(n);
+    }
+
+    public int min() {
+        return minq.getFirst();
+    }
+
+    // 若元素大于    队列头部元素，那么会在添加的时候自动删除
+    // 所以我们只需要判断是否为第一个元素，是的话才需要手动删除
+    public void pop(int n) {
+        if(n==minq.getFirst()) {
+            minq.pollFirst();
+        }
+    }
+}
diff --git a/algorithm/src/main/java/array/slideWindow/Permutation.java b/algorithm/src/main/java/array/slideWindow/Permutation.java
new file mode 100644
index 0000000..fc8a713
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/Permutation.java
@@ -0,0 +1,50 @@
+package array.slideWindow;
+
+import java.util.HashMap;
+
+/**
+ * 567. 字符串的排列
+ */
+
+public class Permutation {
+
+    public boolean permutation(String s1, String s2) {
+        HashMap<Character, Integer> map = new HashMap<>();
+        HashMap<Character, Integer> need = new HashMap<>();
+
+        int left=0, right=0;
+        int count=0;
+
+        // 参数初始化
+        for(int i=0; i<s1.length();i++) {
+            char c = s1.charAt(i);
+            need.put(c, need.getOrDefault(c, 0)+1);
+        }
+
+        while(right<s2.length()) {
+            char c = s2.charAt(right);
+            map.put(c, map.getOrDefault(c,0)+1);
+            if(map.get(c).equals(need.getOrDefault(c, 0))) {
+                count++;
+            }
+            right++;
+
+
+            while(right-left>=s1.length()) {
+                if(right-left==count) {
+                    return true;
+                }
+
+                char t = s2.charAt(left);
+                if(map.get(t).equals(need.getOrDefault(t, 0))) {
+                    count --;
+                }
+                map.replace(t, map.get(t)-1);
+                left++;
+
+            }
+        }
+        return false;
+
+    }
+}
diff --git a/algorithm/src/main/java/array/slideWindow/SlidingWindowMaximum.java b/algorithm/src/main/java/array/slideWindow/SlidingWindowMaximum.java
new file mode 100644
index 0000000..614e6e3
--- /dev/null
+++ b/algorithm/src/main/java/array/slideWindow/SlidingWindowMaximum.java
@@ -0,0 +1,84 @@
+package array.slideWindow;
+
+import java.util.*;
+
+/**
+ * 239. 滑动窗⼝最⼤值
+ */
+
+public class SlidingWindowMaximum {
+
+    // 两个循环，时间复杂度为O(kN)
+    public int[] maximumWindow(int[] nums, int k) {
+        // 参数处理
+        if(k<1 || nums.length<k) {
+            return new int[]{};
+        }
+
+        int left=0, right=0;
+        int[] res = new int[nums.length+1-k];
+
+        for(int i=k;i<=nums.length;i++) {
+            int temp = Integer.MIN_VALUE;
+            for(int j=i-k;j<i;j++) {
+                temp = Math.max(temp, nums[j]);
+            }
+            res[i-k] = temp;
+//            System.out.println(temp);
+        }
+
+        return res;
+    }
+
+    // 使用单调队列求解，时间复杂度为O(N)
+    public int[] maximumWindow2(int[] nums, int k) {
+        if (k < 1 || nums.length < k) {
+            return new int[]{};
+        }
+
+        MonotonicQueue window = new MonotonicQueue();
+        int[] res = new int[nums.length+1-k];
+
+        for(int i=0;i<nums.length;i++) {
+            if(i<k-1) {
+                // 先填满窗口的前 k - 1
+                window.push(nums[i]);
+            }else {
+                window.push(nums[i]);
+                res[i+1-k]=window.max();
+                // 移除最左侧数据
+                window.pop(nums[i+1-k]);
+            }
+        }
+        return res;
+    }
+
+
+}
+
+/* 单调队列的实现 */
+class MonotonicQueue {
+    // 队列的第一个值最大，后面的值按照添加顺序排列
+    LinkedList<Integer> maxq = new LinkedList<Integer>();
+
+    public void push(int n) {
+        // 将小于 n 的元素全部删除(等于时保留)
+        while(!maxq.isEmpty() && maxq.getLast()<n) {
+            maxq.pollLast();
+        }
+        // 然后将 n 加入尾部
+        maxq.addLast(n);
+    }
+
+    public int max() {
+        return maxq.getFirst();
+    }
+
+    // 若元素小于队列头部元素，那么会在添加的时候自动删除
+    // 所以我们只需要判断是否为第一个元素，是的话才需要手动删除
+    public void pop(int n) {
+        if(n==maxq.getFirst()) {
+            maxq.pollFirst();
+        }
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/CombinationSum.java b/algorithm/src/main/java/backTrack/CombinationSum.java
new file mode 100644
index 0000000..5f1b607
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/CombinationSum.java
@@ -0,0 +1,38 @@
+package backTrack;
+
+/**
+ * 39 组合总和
+ */
+
+import java.util.ArrayList;
+
+public class CombinationSum {
+
+    public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+
+        // 初始化值为false
+//        boolean[] visited = new boolean[candidates.length];
+        ArrayList<Integer> temp = new ArrayList<>();
+
+        backtrack(0, candidates, target, temp, res);
+
+        return res;
+    }
+
+    void backtrack(int start, int[] candidates, int target, ArrayList<Integer> temp, ArrayList<ArrayList<Integer>> res) {
+        if(target == 0) {
+            res.add(new ArrayList<>(temp));
+            return;
+        } else if(target < 0) {
+            return;
+        }
+
+        //从当前的位置往后遍历，可以排除例如[2,2,3]和[2,3,2]的情况，最终得到[2,2,3]
+        for(int i=start; i<candidates.length; i++) {
+            temp.add(candidates[i]);
+            backtrack(i, candidates, target-candidates[i], temp, res);
+            temp.remove(temp.size()-1);
+        }
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/Combinations.java b/algorithm/src/main/java/backTrack/Combinations.java
new file mode 100644
index 0000000..96f7091
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/Combinations.java
@@ -0,0 +1,49 @@
+package backTrack;
+
+/**
+ * 77 组合
+ */
+
+import java.util.ArrayList;
+
+public class Combinations {
+
+    public ArrayList<ArrayList<Integer>> combinations(int n, int k) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+        ArrayList<Integer> temp = new ArrayList<>();
+        boolean[] visited = new boolean[n];
+        int[] nums = new int[n];
+        for(int i=0;i<n;i++) {
+            nums[i] = i+1;
+        }
+        backtrack(0, k, visited, nums, temp, res);
+
+        return res;
+    }
+
+    void backtrack(int start, int k, boolean[] visited, int[] nums, ArrayList<Integer> temp, ArrayList<ArrayList<Integer>> res) {
+        if(k==temp.size()) {
+            res.add(new ArrayList<>(temp));
+        }
+
+        for(int i=start;i<nums.length;i++) {
+            if(visited[i]) {
+                continue;
+            }
+            temp.add(nums[i]);
+            visited[i] = true;
+            backtrack(i, k, visited, nums, temp, res);
+            temp.remove(temp.size()-1);
+            visited[i] = false;
+        }
+    }
+    /**
+     * [1, 2]
+     * [1, 3]
+     * [1, 4]
+     * [2, 3]
+     * [2, 4]
+     * [3, 4]
+     */
+
+}
diff --git a/algorithm/src/main/java/backTrack/GenerateParentheses.java b/algorithm/src/main/java/backTrack/GenerateParentheses.java
new file mode 100644
index 0000000..410e0d8
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/GenerateParentheses.java
@@ -0,0 +1,54 @@
+package backTrack;
+
+import java.util.ArrayList;
+
+/**
+ * 22 括号生成
+ */
+
+
+/**
+ * 回溯算法
+ * 左括号数不得小于右括号数
+ */
+public class GenerateParentheses {
+
+    public ArrayList<String> generateParentheses(int n) {
+        ArrayList<String> res = new ArrayList<>();
+        backtrack(n, n, new StringBuilder(), res);
+        return res;
+    }
+
+    void backtrack(int left, int right, StringBuilder s, ArrayList<String>res) {
+        // 左括号数量小于右括号，表明括号不合法
+        if(left > right) {
+            return;
+        }
+        // 数量小于0，表示不合法
+        if(left < 0 || right < 0) {
+            return;
+        }
+        // 当所有的括号都恰好用完，表明合法
+        if(left==0 && right==0) {
+            res.add(new String(s));
+            return;
+        }
+
+        // 添加左括号
+        s.append('(');
+        backtrack(left-1, right, s, res);
+        // 撤销添加
+        s.deleteCharAt(s.length()-1);
+
+        // 添加右括号
+        s.append(')');
+        backtrack(left, right-1, s, res);
+        // 撤销添加
+        s.deleteCharAt(s.length()-1);
+
+
+
+    }
+
+
+}
diff --git a/algorithm/src/main/java/backTrack/MaximumDepthBinaryTree.java b/algorithm/src/main/java/backTrack/MaximumDepthBinaryTree.java
new file mode 100644
index 0000000..236f36c
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/MaximumDepthBinaryTree.java
@@ -0,0 +1,22 @@
+package backTrack;
+
+/**
+ * 104 二叉树最大深度
+ */
+
+import java.util.ArrayList;
+
+public class MaximumDepthBinaryTree {
+
+    int maximumDepth(ArrayList<Integer> nums) {
+        int res = 0;
+        backtrack();
+
+        return res;
+
+    }
+
+    public void backtrack() {
+
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/NQueues.java b/algorithm/src/main/java/backTrack/NQueues.java
new file mode 100644
index 0000000..9087446
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/NQueues.java
@@ -0,0 +1,77 @@
+package backTrack;
+
+/**
+ * 52 N-Queues
+ */
+
+import java.util.ArrayList;
+
+public class NQueues {
+
+    public ArrayList<ArrayList<String>> nQueues(int n) {
+        ArrayList<ArrayList<String>> res = new ArrayList<>();
+        char[][] board = new char[n][n];
+        for(int i=0; i<n; i++) {
+            for(int j=0; j<n; j++) {
+                board[i][j] = '.';
+            }
+        }
+
+        backtrack(board, 0, res);
+
+        return res;
+    }
+
+    void backtrack(char[][] board, int row,  ArrayList<ArrayList<String>> res) {
+        if(row==board.length) {
+            ArrayList<String> temp = new ArrayList<>();
+            for(int i=0; i<board.length; i++) {
+                StringBuilder s = new StringBuilder();
+                for(int j=0; j<board[0].length; j++) {
+                    s.append(board[i][j]);
+                }
+                temp.add(s.toString());
+            }
+            res.add(temp);
+            return;
+        }
+
+        for(int col=0; col<board.length; col++) {
+                if(isValid(board, row, col)) {
+                    board[row][col] = 'Q';
+                    backtrack(board, row+1, res);
+                    board[row][col] = '.';
+                }
+        }
+
+
+    }
+
+    boolean isValid(char[][] board, int row, int col) {
+
+        // 判断水平-竖直方向是否有效
+        for(int i=0; i<row; i++) {
+            // 判断竖直方向是否有效
+            if(board[i][col]=='Q') {
+                return false;
+            }
+
+        }
+
+        // 判断右上方向是否有效
+        for(int i=row-1, j=col+1; i>=0 && j<board.length; i--,j++) {
+            if(board[i][j]=='Q') {
+                return false;
+            }
+        }
+
+        // 判断左上方向是否有效
+        for(int i=row-1, j=col-1; i>=0 && j>=0; i--,j--) {
+            if(board[i][j]=='Q') {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/PartitionKEqualSumSubsets.java b/algorithm/src/main/java/backTrack/PartitionKEqualSumSubsets.java
new file mode 100644
index 0000000..25073d0
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/PartitionKEqualSumSubsets.java
@@ -0,0 +1,53 @@
+package backTrack;
+
+/**
+ * 698 划分为k个相等的子集
+ */
+
+public class PartitionKEqualSumSubsets {
+
+    public boolean partitionKEqualSumSubsets(int[] nums, int k) {
+        int sum = 0;
+        for(int i=0; i<nums.length; i++) {
+            sum += nums[i];
+        }
+        if(sum%k > 0) {
+            return false;
+        }
+
+        int target = sum /k;
+        boolean[] visited = new boolean[nums.length];
+
+        boolean res = backtrack(k, nums, 0, visited, target);
+
+        return res;
+    }
+
+    boolean backtrack(int k, int[] nums, int bucket, boolean[] visited, int target) {
+        if(k==0) {
+            return true;
+        }
+
+        //桶装满了，那么装下一个桶
+        if(bucket==target) {
+            return backtrack(k-1, nums, 0, visited, target);
+        }
+
+        for(int i=0; i<nums.length; i++) {
+            if(visited[i]) {
+                continue;
+            }
+
+            bucket += nums[i];
+            visited[i] = true;
+            if(backtrack(k, nums, bucket, visited, target)) {
+                return true;
+            }
+
+            bucket-=nums[i];
+            visited[i] = false;
+        }
+
+        return false;
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/Permutations.java b/algorithm/src/main/java/backTrack/Permutations.java
new file mode 100644
index 0000000..672d990
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/Permutations.java
@@ -0,0 +1,40 @@
+package backTrack;
+
+/**
+ * 46 全排列
+ */
+
+import java.util.ArrayList;
+
+public class Permutations {
+
+    ArrayList<ArrayList<Integer>> permutations(int[] nums) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+        ArrayList<Integer> temp = new ArrayList<>();
+        boolean[] visited = new boolean[nums.length];
+        backtrack(nums, visited, temp, res);
+        return res;
+    }
+
+    void backtrack(int[] nums, boolean[] visited, ArrayList<Integer> temp, ArrayList<ArrayList<Integer>> res) {
+        if(nums.length==temp.size()) {
+            res.add(new ArrayList<>(temp));
+            return;
+        }
+
+        for(int i=0; i<nums.length;i++) {
+            // 如果已经使用，那么直接跳过
+            if(visited[i]) {
+                continue;
+            }
+            temp.add(nums[i]);
+            visited[i] = true;
+            backtrack(nums, visited, temp, res);
+            temp.remove(temp.size()-1);
+            visited[i] = false;
+        }
+
+
+
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/Subsets.java b/algorithm/src/main/java/backTrack/Subsets.java
new file mode 100644
index 0000000..294448d
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/Subsets.java
@@ -0,0 +1,24 @@
+package backTrack;
+
+import java.util.ArrayList;
+
+public class Subsets {
+
+    public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+        ArrayList<Integer> temp = new ArrayList<>();
+        backtrack(0, nums, temp, res);
+
+        return res;
+    }
+
+    void backtrack(int start,int[] nums, ArrayList<Integer> temp, ArrayList<ArrayList<Integer>> res) {
+        res.add(new ArrayList<>(temp));
+
+        for(int i=start; i<nums.length; i++) {
+            temp.add(nums[i]);
+            backtrack(i+1, nums, temp, res);
+            temp.remove(temp.size()-1);
+        }
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/SudokuSolver.java b/algorithm/src/main/java/backTrack/SudokuSolver.java
new file mode 100644
index 0000000..dfa8a98
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/SudokuSolver.java
@@ -0,0 +1,70 @@
+package backTrack;
+
+/**
+ * 37 解数独
+ */
+
+// 9x9的格子布局
+public class SudokuSolver {
+
+    public void sudokuSolver(char[][] board) {
+
+        backtrack(0,0, board);
+    }
+
+    boolean backtrack(int row, int col, char[][] board) {
+        // 最后一列，那么换行
+        if(col==9) {
+            return backtrack(row+1, 0, board);
+        }
+        // 最后一行已经穷举完成，得到正确结果
+        if(row==9) {
+            return true;
+        }
+
+        // 如果有预设数据，那么不用我们穷举
+        if(board[row][col] != '.') {
+            return backtrack(row, col+1, board);
+        }
+
+        for(char ch='1'; ch<='9'; ch++) {
+            if(isValid(row, col, board, ch)) {
+                board[row][col] = ch;
+
+                // 如果找到可行解，那么立即结束
+                if(backtrack(row, col+1, board)) {
+                    return true;
+                }
+                board[row][col] = '.';
+            }
+        }
+
+        // 穷举完1-9，依旧没有找到可行解
+        return false;
+    }
+
+    boolean isValid(int row, int col, char[][] board, char n) {
+        for(int i=0; i<9; i++) {
+            // 判断行是否满足
+            if (board[row][i] == n) {
+                return false;
+            }
+
+            // 判断列是否满足
+            if (board[i][col] == n) {
+                return false;
+            }
+        }
+
+        //判断3x3格子是否满足
+        for(int i=row/3*3; i< row/3*3+3; i++) {
+            for(int j=col/3*3; j< col/3*3+3; j++) {
+                if(board[i][j] == n) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/TargetSum.java b/algorithm/src/main/java/backTrack/TargetSum.java
new file mode 100644
index 0000000..2e604bf
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/TargetSum.java
@@ -0,0 +1,38 @@
+package backTrack;
+
+/**
+ * 494 目标和
+ */
+
+public class TargetSum {
+
+    int sum = 0;
+    int res = 0;
+
+    public int targetSum(int[] nums, int target) {
+//        int res = 0;
+//        backtrack(0, target, nums, 0, res);
+
+        backtrack(0, target, nums);
+
+        return res;
+    }
+
+    void backtrack(int start, int target, int[] nums) {
+        if(start==nums.length) {
+            if(target == sum) {
+                res +=1;
+            }
+            return;
+        }
+
+        sum += nums[start];
+        backtrack(start+1, target, nums);
+        sum -= nums[start];
+
+        sum -= nums[start];
+        backtrack(start+1, target, nums);
+        sum += nums[start];
+
+    }
+}
diff --git a/algorithm/src/main/java/backTrack/TargetSum2.java b/algorithm/src/main/java/backTrack/TargetSum2.java
new file mode 100644
index 0000000..e4a179c
--- /dev/null
+++ b/algorithm/src/main/java/backTrack/TargetSum2.java
@@ -0,0 +1,38 @@
+package backTrack;
+
+/**
+ * 494 目标和
+ */
+
+public class TargetSum2 {
+
+//    int sum = 0;
+    int res = 0;
+
+    public int targetSum(int[] nums, int target) {
+//        int res = 0;
+//        backtrack(0, target, nums, 0, res);
+
+        backtrack(0, target, nums, 0);
+
+        return res;
+    }
+
+    void backtrack(int start, int target, int[] nums, int sum) {
+        if(start==nums.length) {
+            if(target == sum) {
+                res +=1;
+            }
+            return;
+        }
+
+        sum += nums[start];
+        backtrack(start+1, target, nums, sum);
+        sum -= nums[start];
+
+        sum -= nums[start];
+        backtrack(start+1, target, nums, sum);
+        sum += nums[start];
+
+    }
+}
diff --git a/algorithm/src/main/java/binaryHeap/KthLargestData.java b/algorithm/src/main/java/binaryHeap/KthLargestData.java
new file mode 100644
index 0000000..79a366f
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/KthLargestData.java
@@ -0,0 +1,27 @@
+package binaryHeap;
+
+import java.util.PriorityQueue;
+
+public class KthLargestData {
+    // 从小到大排序，容量为k
+    PriorityQueue<Integer> large = new PriorityQueue<>((a,b) -> {
+        return a-b;
+    });
+    int capacity;
+
+
+    public KthLargestData(int k, int[] nums) {
+        capacity = k;
+        for(int num : nums) {
+            this.add(num);
+        }
+    }
+
+    public int add(int val) {
+        large.add(val);
+        if(large.size()>capacity) {
+            large.poll();
+        }
+        return large.peek();
+    }
+}
diff --git a/algorithm/src/main/java/binaryHeap/KthLargestElement.java b/algorithm/src/main/java/binaryHeap/KthLargestElement.java
new file mode 100644
index 0000000..fd14eb2
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/KthLargestElement.java
@@ -0,0 +1,44 @@
+package binaryHeap;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+/**
+ * 215. 数组中的第K个最⼤元素
+ */
+
+public class KthLargestElement {
+
+    public int kthLargest(int[] nums, int k) {
+        int res = 0;
+
+//        Comparator<Integer> comparator = new Comparator<Integer>() {
+//            @Override
+//            public int compare(Integer o1, Integer o2) {
+//                return o1-o2; // 从小到大排序
+//            }
+//        };
+
+//        PriorityQueue<Integer> queue = new PriorityQueue<>(comparator);
+        // 等价于
+
+        // 从小到大排序
+        PriorityQueue<Integer> queue = new PriorityQueue<Integer>(
+                (o1, o2) -> {
+                    return o1-o2;
+                }
+        );
+        for(int i=0;i<nums.length;i++) {
+            queue.add(nums[i]);
+            if(queue.size()>k) {
+                queue.poll(); // 移除最上面的元素
+            }
+        }
+        res = queue.peek();
+
+
+        return res;
+    }
+
+
+}
diff --git a/algorithm/src/main/java/binaryHeap/MaxFrequency.java b/algorithm/src/main/java/binaryHeap/MaxFrequency.java
new file mode 100644
index 0000000..c3c8ecd
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/MaxFrequency.java
@@ -0,0 +1,18 @@
+package binaryHeap;
+
+/**
+ * 895. 最⼤频率栈
+ * ========================  未完成
+ */
+
+public class MaxFrequency {
+
+
+
+    public void push(int val) {
+    }
+
+    public int pop() {
+        return -1;
+    }
+}
diff --git a/algorithm/src/main/java/binaryHeap/MedianData.java b/algorithm/src/main/java/binaryHeap/MedianData.java
new file mode 100644
index 0000000..6ccd7bb
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/MedianData.java
@@ -0,0 +1,49 @@
+package binaryHeap;
+
+/**
+ * 295 数据流中的中位数
+ */
+
+import java.util.PriorityQueue;
+
+public class MedianData {
+    // large的最小值 >= small的最大值
+    // 从小到大排序
+    private PriorityQueue<Integer> large = new PriorityQueue<>((a, b) -> {
+        return a-b;
+    });
+    // 从大到小排序
+    private PriorityQueue<Integer> small = new PriorityQueue<>((a, b) -> {
+        return b-a;
+    });
+
+    public void addNum(int num) {
+        // 先往small队列中存入值，然后将最大值传递给large队列
+        if(small.size()>large.size()) {
+            small.add(num);
+            Integer temp = small.poll();
+            large.add(temp);
+        } else {
+            large.add(num);
+            small.add(large.poll());
+        }
+
+    }
+
+    public double findMedian() {
+        // 判断数据小于2个的情况
+        if(small.isEmpty() && large.isEmpty()) {
+            return 0;
+        } else if(large.isEmpty()) {
+            return small.peek();
+        }
+        // 若small队列长度>大于large队列长度，那么small顶部就是中位数
+        if(small.size()==large.size()) {
+            return (small.peek()+large.peek())/2.0;
+        } else if(small.size()<large.size()) {
+            return large.peek();
+        } else {
+            return small.peek();
+        }
+    }
+}
diff --git a/algorithm/src/main/java/binaryHeap/MinStack.java b/algorithm/src/main/java/binaryHeap/MinStack.java
new file mode 100644
index 0000000..fdbea07
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/MinStack.java
@@ -0,0 +1,46 @@
+package binaryHeap;
+
+import java.util.PriorityQueue;
+import java.util.Stack;
+
+/**
+ * 155. 最⼩栈
+ */
+
+public class MinStack {
+
+    private Stack<Integer> stack = new Stack<>();
+    // 从小到大排序
+    private Stack<Integer> min = new Stack<>();
+
+    public MinStack() {
+
+    }
+
+    public void push(int val) {
+        stack.push(val);
+        if(min.isEmpty()) {
+            min.add(val);
+        } else if(min.peek()>val) {
+            min.add(val);
+        } else {
+            min.add(min.peek());
+        }
+    }
+
+    public void pop() {
+        stack.pop();
+        min.pop();
+    }
+
+    public int top() {
+        return stack.peek();
+    }
+
+    public int getMin() {
+        return min.peek();
+    }
+
+
+
+}
diff --git a/algorithm/src/main/java/binaryHeap/SeatReserve.java b/algorithm/src/main/java/binaryHeap/SeatReserve.java
new file mode 100644
index 0000000..4bc469b
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/SeatReserve.java
@@ -0,0 +1,38 @@
+package binaryHeap;
+
+/**
+ * 1845. 座位预约管理系统
+ */
+
+import java.util.PriorityQueue;
+
+public class SeatReserve {
+
+    // 从小到大排序，表示可预订座位编号
+    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>((a, b) -> {
+        return a-b;
+    });
+    private int num;
+
+    public SeatReserve(int n) {
+        num = n;
+        for(int i=0;i<n;i++) {
+            queue.add(i+1);
+        }
+    }
+
+    public int reserve() {
+        // 可预订情况下，优先预定小编号座位
+        if(queue.size()>0) {
+            return queue.poll();
+        } else {
+            return -1;
+        }
+    }
+
+    public void unreserve(int seatNumber) {
+        if(queue.size()<num) {
+            queue.add(seatNumber);
+        }
+    }
+}
diff --git a/algorithm/src/main/java/binaryHeap/SingleThreadCPU.java b/algorithm/src/main/java/binaryHeap/SingleThreadCPU.java
new file mode 100644
index 0000000..ed6c9a3
--- /dev/null
+++ b/algorithm/src/main/java/binaryHeap/SingleThreadCPU.java
@@ -0,0 +1,91 @@
+package binaryHeap;
+
+/**
+ * 1834. 单线程 CPU
+ */
+
+
+
+import java.util.ArrayList;
+import java.util.PriorityQueue;
+
+public class SingleThreadCPU {
+
+    // 我的方法
+    public int[] singleThreadCPU(int[][] tasks) {
+
+        class Task {
+            // 任务起始时间
+            int start;
+            // 任务终止时间
+            int end;
+            // 执行任务所需要花费的时间
+            int cost;
+            // 任务索引
+            int index;
+            Task(int index, int start, int cost) {
+                this.start = start;
+                this.end = start+ cost;
+                this.cost = cost;
+                this.index = index;
+            }
+        }
+
+        int[] res = new int[tasks.length];
+        // 对任务的起始时间、执行时长、任务编号从小到大排序
+        PriorityQueue<Task> queue1 = new PriorityQueue<Task>(
+            (Task o1, Task o2) -> {
+                if(o1.start==o2.start) {
+                    if(o1.cost==o2.cost) {
+                        return o1.index-o2.index;
+                    }else {
+                        return o1.cost-o2.cost;
+                    }
+                }else {
+                    return o1.start - o2.start;
+                }
+            });
+        // 对任务执行时长、索引编号从小到大排序
+        PriorityQueue<Task> queue2 = new PriorityQueue<>(
+                (o1, o2) -> {
+                    if(o1.cost==o2.cost) {
+                        return o1.index-o2.index;
+                    }else {
+                        return o1.cost-o2.cost;
+                    }
+                }
+        );
+
+        // 实例化Task
+        for(int i=0; i<tasks.length; i++) {
+            queue1.add(new Task(i, tasks[i][0], tasks[i][1]));
+        }
+
+        // 设置任务执行时间起点，小于该起点的任务均会添加到queue2中
+        int start=0;
+        // 保存到结果的索引值
+        int p = 0;
+        while(!queue1.isEmpty() || !queue2.isEmpty()) {
+            // 取出queue1中数据，添加到queue2中
+            while (!queue1.isEmpty() && queue1.peek().start<=start) {
+                queue2.add( queue1.poll());
+            }
+
+            // 若为空，那么从queue1中存入数据
+            if(queue2.isEmpty()) {
+                assert queue1.peek() != null;
+                start = queue1.peek().start;
+                queue2.add(queue1.poll());
+            }
+
+            // 取出queue中的任务执行
+            Task t2 = queue2.poll();
+            res[p] = t2.index;
+            p++;
+            start = Math.max(start, t2.end);
+
+        }
+        return res;
+
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/BinaryTreeLevelOrderTraversal.java b/algorithm/src/main/java/binaryTree/BinaryTreeLevelOrderTraversal.java
new file mode 100644
index 0000000..2bcea3a
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/BinaryTreeLevelOrderTraversal.java
@@ -0,0 +1,30 @@
+package binaryTree;
+
+import java.util.ArrayList;
+
+/**
+ *  102 二叉树层序遍历
+ */
+
+public class BinaryTreeLevelOrderTraversal {
+
+    ArrayList<ArrayList<Integer>> binaryTreeLevelOrderTraversal(TreeNode root) {
+
+        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
+        traverse(root, 0, res);
+        return res;
+    }
+
+    void traverse(TreeNode root, int level, ArrayList<ArrayList<Integer>> res) {
+        if(root==null) {
+            return;
+        }
+        if(level>=res.size()) {
+            res.add(new ArrayList<>());
+        }
+        res.get(level).add(root.val);
+
+        traverse(root.left, level+1, res);
+        traverse(root.right, level+1, res);
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/BinaryTreePostorderTraversal.java b/algorithm/src/main/java/binaryTree/BinaryTreePostorderTraversal.java
new file mode 100644
index 0000000..db81d07
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/BinaryTreePostorderTraversal.java
@@ -0,0 +1,28 @@
+package binaryTree;
+
+import java.util.LinkedList;
+
+/**
+ *  145 二叉树的后续遍历
+ */
+
+public class BinaryTreePostorderTraversal {
+    LinkedList<Integer> binaryTreePostorderTraversal(TreeNode root) {
+        LinkedList<Integer> res = new LinkedList<>();
+
+        traverse(root, res);
+
+        return res;
+    }
+
+    void traverse(TreeNode root, LinkedList<Integer> res) {
+        if(root==null) {
+            return;
+        }
+        traverse(root.left, res);
+        traverse(root.right, res);
+        res.addFirst(root.val);
+    }
+
+
+}
diff --git a/algorithm/src/main/java/binaryTree/BinaryTreeZigzagLevelOrderTraversal.java b/algorithm/src/main/java/binaryTree/BinaryTreeZigzagLevelOrderTraversal.java
new file mode 100644
index 0000000..aa28cd8
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/BinaryTreeZigzagLevelOrderTraversal.java
@@ -0,0 +1,39 @@
+package binaryTree;
+
+/**
+ * [103. 二叉树的锯齿形层序遍历]
+ */
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinaryTreeZigzagLevelOrderTraversal {
+
+    public LinkedList<LinkedList<Integer>> zigzagOrder(TreeNode root) {
+        LinkedList<LinkedList<Integer>> res = new LinkedList<>();
+
+        traverse(root, 0, res);
+        return res;
+    }
+
+    void traverse(TreeNode root, int level, LinkedList<LinkedList<Integer>> res) {
+        if(root==null) {
+            return;
+        }
+        if(level>=res.size()) {
+//            System.out.println(root.val);
+            res.add(new LinkedList<>());
+        }
+
+        // 偶数层从左到右，奇数层从右到左
+        if(level%2==1) {
+            res.get(level).addFirst(root.val);
+        }else {
+            res.get(level).add(root.val);
+        }
+
+        traverse(root.left, level+1, res);
+        traverse(root.right, level+1, res);
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/DiameterBinaryTree.java b/algorithm/src/main/java/binaryTree/DiameterBinaryTree.java
new file mode 100644
index 0000000..77359f3
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/DiameterBinaryTree.java
@@ -0,0 +1,24 @@
+package binaryTree;
+
+/**
+ *  543 二叉树的直径
+ */
+
+public class DiameterBinaryTree {
+
+    public int diameterBinaryTree(TreeNode root) {
+        int left =  traverse(root.left);
+        int right = traverse(root.right);
+        return left+right;
+    }
+
+    int traverse(TreeNode root) {
+        if(root==null) {
+            return 0;
+        }
+
+        int left = traverse(root.left);
+        int right = traverse(root.right);
+        return 1+Math.max(left, right);
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/FlattenBinaryTreeToLinkedList.java b/algorithm/src/main/java/binaryTree/FlattenBinaryTreeToLinkedList.java
new file mode 100644
index 0000000..7c18871
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/FlattenBinaryTreeToLinkedList.java
@@ -0,0 +1,37 @@
+package binaryTree;
+
+import java.util.LinkedList;
+
+/**
+ *  114 二叉树展开为链表
+ */
+
+public class FlattenBinaryTreeToLinkedList {
+
+    LinkedList<TreeNode> flattenBinaryTreeToLinkedList(TreeNode root) {
+        LinkedList<TreeNode> res = new LinkedList<>();
+        traverse(root, res);
+        // 重新排列
+        for(int i=0; i<res.size()-1; i++) {
+            TreeNode t = res.get(i);
+            t.left = null;
+            t.right = res.get(i+1);
+        }
+        return res;
+    }
+
+    void traverse(TreeNode root, LinkedList<TreeNode> res) {
+        if(root==null) {
+            return;
+        }
+//        if(res.size()>0) {
+//            TreeNode last = res.getLast();
+//            last.left = null;
+//            last.right = root;
+//        }
+        res.add(root);
+        traverse(root.left, res);
+        traverse(root.right, res);
+
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/InorderTraversal.java b/algorithm/src/main/java/binaryTree/InorderTraversal.java
new file mode 100644
index 0000000..0e23281
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/InorderTraversal.java
@@ -0,0 +1,46 @@
+package binaryTree;
+
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 94. ⼆叉树的中序遍历
+ */
+
+public class InorderTraversal {
+    /* 回溯算法思路*/
+    LinkedList<Integer> res = new LinkedList<>();
+
+
+    // 中序遍历结果
+    public List<Integer> inorderTraversal(TreeNode root) {
+        LinkedList<Integer> res = new LinkedList<>();
+        if(root == null) {
+            return res;
+        }
+
+        res.addAll(inorderTraversal(root.left));
+        res.add(root.val);
+        res.addAll(inorderTraversal(root.right));
+        return res;
+    }
+
+    // 返回前序遍历结果
+    public List<Integer> preorderTraversal(TreeNode root) {
+        traverse(root);
+        return res;
+    }
+
+    // 二叉树遍历函数
+    void traverse(TreeNode root) {
+        if(root == null) {
+            return;
+        }
+
+        traverse(root.left);
+        //中序遍历
+        res.add(root.val);
+        traverse(root.right);
+    }
+
+}
diff --git a/algorithm/src/main/java/binaryTree/InvertBinaryTree.java b/algorithm/src/main/java/binaryTree/InvertBinaryTree.java
new file mode 100644
index 0000000..b95c22e
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/InvertBinaryTree.java
@@ -0,0 +1,28 @@
+package binaryTree;
+
+/**
+ *  226 翻转二叉树
+ */
+
+public class InvertBinaryTree {
+
+    public void invertBinaryTree(TreeNode root) {
+        traverse(root);
+    }
+
+    void traverse(TreeNode root) {
+        if(root==null) {
+            return;
+        }
+
+
+        TreeNode temp = null;
+        temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        traverse(root.left);
+        traverse(root.right);
+
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/LevelOrderTraversal.java b/algorithm/src/main/java/binaryTree/LevelOrderTraversal.java
new file mode 100644
index 0000000..5bee268
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/LevelOrderTraversal.java
@@ -0,0 +1,45 @@
+package binaryTree;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 102. ⼆叉树的层序遍历
+ */
+
+public class LevelOrderTraversal {
+
+
+
+    LinkedList<LinkedList<Integer>> levelOrderTraversal(TreeNode root) {
+        LinkedList<LinkedList<Integer>> res = new LinkedList<>();
+
+        if(root == null) {
+            return res;
+        }
+
+        Queue<TreeNode> q = new LinkedList<>();
+        q.offer(root); // 添加二叉树
+        while(!q.isEmpty()) {
+            int sz = q.size();
+            // 记录下这一层节点值
+            LinkedList<Integer> temp = new LinkedList<>();
+            // for循环控制每一层从左向右遍历
+            for(int i=0;i<sz;i++) {
+                TreeNode curr = q.poll(); // 弹出二叉树节点
+                temp.add(curr.val);
+                if(curr.left!=null){
+                    q.offer(curr.left);
+                }
+                if(curr.right!=null){
+                    q.offer(curr.right);
+                }
+                res.add(temp);
+            }
+        }
+        return res;
+    }
+
+
+
+}
diff --git a/algorithm/src/main/java/binaryTree/MaximumDepth.java b/algorithm/src/main/java/binaryTree/MaximumDepth.java
new file mode 100644
index 0000000..2a4e4f7
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/MaximumDepth.java
@@ -0,0 +1,15 @@
+package binaryTree;
+
+/**
+ * 104. 二叉树的最大深度
+ */
+
+public class MaximumDepth {
+
+    int maximumDepth(TreeNode root){
+        int res = 0;
+
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/MaximumDepthNTree.java b/algorithm/src/main/java/binaryTree/MaximumDepthNTree.java
new file mode 100644
index 0000000..a610b10
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/MaximumDepthNTree.java
@@ -0,0 +1,10 @@
+package binaryTree;
+
+/**
+ *  559 N叉树的最大深度
+ */
+
+public class MaximumDepthNTree {
+
+
+}
diff --git a/algorithm/src/main/java/binaryTree/MinimumDepthBinaryTree.java b/algorithm/src/main/java/binaryTree/MinimumDepthBinaryTree.java
new file mode 100644
index 0000000..1e01dc0
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/MinimumDepthBinaryTree.java
@@ -0,0 +1,25 @@
+package binaryTree;
+
+/**
+ *  111 二叉树最小深度
+ */
+
+public class MinimumDepthBinaryTree {
+
+    int minimumDepthBinaryTree(TreeNode root) {
+        int res = 0;
+        res = traverse(root);
+        return res;
+    }
+
+    int traverse(TreeNode root) {
+        if(root==null) {
+            return 0;
+        }
+
+        int left = traverse(root.left)+1;
+        int right = traverse(root.right)+1;
+        return Math.min(left, right);
+    }
+
+}
diff --git a/algorithm/src/main/java/binaryTree/SameTree.java b/algorithm/src/main/java/binaryTree/SameTree.java
new file mode 100644
index 0000000..d288ced
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/SameTree.java
@@ -0,0 +1,19 @@
+package binaryTree;
+
+/**
+ * 100. 相同的树
+ */
+
+public class SameTree {
+
+    boolean sameTree(TreeNode p, TreeNode q) {
+        if(p==null && q==null) {
+            return true;
+        }else if(p==null || q==null) {
+            return false;
+        }else if(p.val!=q.val) {
+            return false;
+        }
+        return sameTree(p.left, q.left) && sameTree(p.right, q.right);
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/SameTree2.java b/algorithm/src/main/java/binaryTree/SameTree2.java
new file mode 100644
index 0000000..082d07d
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/SameTree2.java
@@ -0,0 +1,30 @@
+package binaryTree;
+
+/**
+ * 100. 相同的树
+ */
+
+public class SameTree2 {
+
+    boolean sameTree(TreeNode p, TreeNode q) {
+
+        return traverse(p, q);
+    }
+
+    boolean traverse(TreeNode p, TreeNode q) {
+        if(p==null && q==null) {
+            return true;
+        }else if(p==null || q==null) {
+            return false;
+        }
+
+        if(p.val!=q.val) {
+            return false;
+        }
+
+        boolean res =  traverse(p.left, q.left) && traverse(p.right, q.right);
+
+        return res;
+    }
+
+}
diff --git a/algorithm/src/main/java/binaryTree/SerializeAndDeserializeBinaryTree.java b/algorithm/src/main/java/binaryTree/SerializeAndDeserializeBinaryTree.java
new file mode 100644
index 0000000..93f8d84
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/SerializeAndDeserializeBinaryTree.java
@@ -0,0 +1,66 @@
+package binaryTree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+/**
+ *  297 二叉树的序列化和反序列化
+ */
+
+public class SerializeAndDeserializeBinaryTree {
+
+    public String serialize(TreeNode root) {
+        StringBuilder res = new StringBuilder();
+        serializeTraverse(root, res);
+
+        // 删除最后一个字符
+        res.deleteCharAt(res.length()-1);
+
+        return res.toString();
+    }
+
+    void serializeTraverse(TreeNode root, StringBuilder res) {
+        if(root==null) {
+            res.append("null").append(",");
+            return;
+        }
+        res.append(Integer.toString(root.val)).append(",");
+        serializeTraverse(root.left, res);
+        serializeTraverse(root.right, res);
+    }
+
+    public TreeNode deserialize(String str) {
+        LinkedList<String> list = new LinkedList<>();
+        for(String t : str.split(",")) {
+            list.add(t);
+        }
+
+        TreeNode res = deserializeTraverse(list);
+
+        return res;
+    }
+
+    TreeNode deserializeTraverse(LinkedList<String> list) {
+        // 采用后序遍历
+        if(list.isEmpty()) {
+            return null;
+        }
+
+        String first = list.removeFirst();
+        if(first.equals("null")) {
+            return null;
+        }
+
+        // 前序创建节点
+        int val = Integer.parseInt(first);
+
+        TreeNode root = new TreeNode(val);
+
+        //后续关联节点
+        root.left = deserializeTraverse(list);
+        root.right = deserializeTraverse(list);
+        return root;
+
+
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/TreeNode.java b/algorithm/src/main/java/binaryTree/TreeNode.java
new file mode 100644
index 0000000..632244d
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/TreeNode.java
@@ -0,0 +1,82 @@
+package binaryTree;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    static LinkedList<Integer> res = new LinkedList<>();
+
+    public TreeNode() {}
+
+    public TreeNode(int val) {
+        this.val = val;
+    }
+
+    public TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+
+    public static LinkedList<Integer> treeNodeToNum(TreeNode root) {
+        LinkedList<Integer> list = new LinkedList<>();
+        preorderTraversal(root, list);
+        return list;
+    }
+
+    // 返回前序遍历结果
+    static void preorderTraversal(TreeNode root, LinkedList<Integer> res) {
+        if(root==null) {
+            return;
+        }
+        res.add(root.val);
+        preorderTraversal(root.left, res);
+        preorderTraversal(root.right, res);
+    }
+
+    // 二叉树遍历函数
+    static void traverse(TreeNode root) {
+        if(root == null) {
+            return;
+        }
+
+        traverse(root.left);
+        //中序遍历
+        res.add(root.val);
+        traverse(root.right);
+    }
+
+    public static TreeNode numsToTreeNode (int[] nums) {
+        if(nums.length==0) {
+            return null;
+        }
+        LinkedList<TreeNode> queue = new LinkedList<>();
+        TreeNode root = new TreeNode(nums[0]);
+        queue.add(root);
+
+        for(int index=1; index< nums.length;) {
+            int size = queue.size();
+            for(int i=0; i<size; i+=1) {
+                TreeNode curr = queue.poll();
+                if(nums[index]!=-1) {
+                    curr.left = new TreeNode(nums[index]);
+                    queue.add(curr.left);
+
+                }
+                index += 1;
+                if(nums[index]!=-1) {
+                    curr.right = new TreeNode(nums[index]);
+                    queue.add(curr.right);
+                }
+                index += 1;
+            }
+        }
+
+        return root;
+    }
+}
diff --git a/algorithm/src/main/java/binaryTree/ZigzagLevelOrderTraversal.java b/algorithm/src/main/java/binaryTree/ZigzagLevelOrderTraversal.java
new file mode 100644
index 0000000..d02a03c
--- /dev/null
+++ b/algorithm/src/main/java/binaryTree/ZigzagLevelOrderTraversal.java
@@ -0,0 +1,44 @@
+package binaryTree;
+
+/**
+ * [103. 二叉树的锯齿形层序遍历]
+ */
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class ZigzagLevelOrderTraversal {
+
+    public LinkedList<LinkedList<Integer>> zigzagOrder(TreeNode root) {
+        LinkedList<LinkedList<Integer>> res = new LinkedList<>();
+        if (root == null) {
+            return res;
+        }
+
+        Queue<TreeNode> q = new LinkedList<>();
+        boolean flag = false;
+        q.offer(root); // 添加
+
+        while (!q.isEmpty()) {
+            int sz = q.size();
+            LinkedList<Integer> temp = new LinkedList<>();
+            for (int i = 0; i < sz; i++) {
+                TreeNode curr = q.poll(); // 弹出
+                if (!flag) {
+                    temp.addFirst(curr.val);
+                }else {
+                    temp.addLast(curr.val);
+                }
+                if(curr.left!=null){
+                    q.offer(curr.left);
+                }
+                if(curr.right!=null){
+                    q.offer(curr.right);
+                }
+            }
+            flag = !flag;
+            res.add(temp);
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/competition/AverageValue.java b/algorithm/src/main/java/competition/AverageValue.java
new file mode 100644
index 0000000..b756dba
--- /dev/null
+++ b/algorithm/src/main/java/competition/AverageValue.java
@@ -0,0 +1,22 @@
+package competition;
+
+/**
+ * 2455 可被三整除的偶数的平均值
+ */
+
+public class AverageValue {
+    public int averageValue(int[] nums) {
+        int res = 0;
+        int count = 0;
+        for(int n: nums) {
+            if(n%6==0) {
+                res+=n;
+                count++;
+            }
+        }
+        if(count>0) {
+            res = res/count;
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/dataStructureDesign/InsertDeleteGetRandom.java b/algorithm/src/main/java/dataStructureDesign/InsertDeleteGetRandom.java
new file mode 100644
index 0000000..53b5cca
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/InsertDeleteGetRandom.java
@@ -0,0 +1,39 @@
+package dataStructureDesign;
+
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Random;
+
+/**
+ *  380 O(1)时间插入、删除、获取随机元素
+ */
+
+public class InsertDeleteGetRandom {
+
+    ArrayList<Integer> data = new ArrayList<>();
+
+    boolean insert(int val) {
+        if(data.contains(val)) {
+            return false;
+        }else {
+            data.add(val);
+            return true;
+        }
+    }
+
+    boolean remove(int val) {
+        if(data.contains(val)) {
+            // 若不转换成对象，那么默认按照索引删除
+            data.remove((Integer) val);
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    int getRandom() {
+        int index = new Random().nextInt()%data.size();
+        return data.get(index);
+    }
+}
diff --git a/algorithm/src/main/java/dataStructureDesign/LFUCache.java b/algorithm/src/main/java/dataStructureDesign/LFUCache.java
new file mode 100644
index 0000000..5641852
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/LFUCache.java
@@ -0,0 +1,86 @@
+package dataStructureDesign;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.PriorityQueue;
+
+/**
+ *  460 LFU缓存
+ */
+
+class LFUNode {
+    int index;
+    int key;
+    int val;
+    int count;
+
+    public LFUNode(int index, int key, int val) {
+        this.index = index;
+        this.key = key;
+        this.val = val;
+        this.count = 0;
+    }
+
+    public void increase() {
+        count++;
+    }
+}
+
+public class LFUCache {
+    int capacity;
+    int index = 0;
+    HashMap<Integer, LFUNode> map = new HashMap<>();
+
+    // 按照访问次数、存放时间从小到大排序、
+    PriorityQueue<LFUNode> queue = new PriorityQueue<>(
+            (o1, o2) -> {
+                if(o1.count==o2.count) {
+                    return o1.index - o2.index;
+                }else {
+                    return o1.count - o2.count;
+                }
+            }
+    );
+
+
+    public LFUCache(int capacity) {
+        this.capacity = capacity;
+    }
+
+    int get(int key) {
+        if(map.containsKey(key)) {
+            LFUNode temp = map.get(key);
+            // 更新访问次数
+            temp.increase();
+            // 更新索引编号
+            temp.index = index;
+            index++;
+            return temp.val;
+        }
+        return -1;
+    }
+
+    void put(int key, int val) {
+        if(map.containsKey(key)) {
+            // 更新数据
+            LFUNode data = map.get(key);
+            data.val = val;
+            data.increase();
+            data.index = index;
+            index++;
+        } else {
+            // 判断是否超过缓存
+            if(map.size()>=capacity) {
+
+                LFUNode d = queue.poll();
+                d.count = 0;
+                map.remove(d.key);
+            }
+
+            LFUNode temp = new LFUNode(index, key, val);
+            map.put(key, temp);
+            queue.add(temp);
+            index++;
+        }
+    }
+}
diff --git a/algorithm/src/main/java/dataStructureDesign/LRUCache.java b/algorithm/src/main/java/dataStructureDesign/LRUCache.java
new file mode 100644
index 0000000..c3a498f
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/LRUCache.java
@@ -0,0 +1,86 @@
+package dataStructureDesign;
+
+import linkedList.doublePointer.ListNode;
+import org.w3c.dom.NodeList;
+
+/**
+ * 146 LRU 缓存机制
+ */
+
+
+class Node {
+    int key;
+    int val;
+    Node next;
+    public Node(int key, int val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+// 使用单链表来处理
+public class LRUCache {
+
+    private int capacity;
+    private int size = 0;
+    Node dummy = new Node(-1, -1);
+
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+    }
+
+    public int get(int key) {
+        Node pre = dummy;
+        Node cur = pre.next;
+        while (cur!=null) {
+            if(cur.key==key) {
+                moveCurrentNode(pre, cur);
+                return cur.val;
+            }
+            pre = pre.next;
+            cur = pre.next;
+        }
+        return -1;
+
+    }
+
+    public void put(int key, int value) {
+
+        Node pre =dummy;
+        Node cur = dummy.next;
+
+        // 先遍历，数据是否存在
+        while (cur!=null) {
+            if(cur.key==key) {
+                cur.val = value;
+                moveCurrentNode(pre, cur);
+                return;
+            }
+            cur = cur.next;
+            // 保留倒数第二个节点
+            if(cur!=null) {
+                pre = pre.next;
+            }
+        }
+
+        // 若数据不存在，那么添加数据
+        Node head = dummy.next;
+        dummy.next = new Node(key, value);
+        dummy.next.next = head;
+        // 节点数自增1
+        size++;
+        if(size>capacity) {
+            pre.next = null;
+            size = capacity;
+        }
+
+    }
+
+    void moveCurrentNode(Node pre, Node cur) {
+        pre.next = cur.next;
+        cur.next = dummy.next;
+        dummy.next = cur;
+    }
+
+
+}
diff --git a/algorithm/src/main/java/dataStructureDesign/LRUCache2.java b/algorithm/src/main/java/dataStructureDesign/LRUCache2.java
new file mode 100644
index 0000000..0c35cbe
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/LRUCache2.java
@@ -0,0 +1,54 @@
+package dataStructureDesign;
+
+import java.util.LinkedHashMap;
+
+/**
+ * 146 LRU 缓存机制
+ */
+
+
+// 使用LinkedHashMap双链表来处理
+
+public class LRUCache2 {
+
+    private int capacity;
+    LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>();
+
+    public LRUCache2(int capacity) {
+        this.capacity = capacity;
+    }
+
+    public int get(int key) {
+        if(map.containsKey(key)) {
+            int value = map.get(key);
+            moveHead(key);
+            return value;
+        }
+        return -1;
+    }
+
+    public void put(int key, int value) {
+        if(map.containsKey(key)) {
+            map.replace(key, value);
+        } else {
+            map.put(key, value);
+        }
+
+        if(map.size()>capacity) {
+            int removeKey = map.keySet().iterator().next();
+            map.remove(removeKey);
+        }
+
+
+    }
+
+    void moveHead(int key) {
+        int value = map.get(key);
+        // 删除元素
+        map.remove(key);
+        // 添加到队尾
+        map.put(key, value);
+    }
+
+
+}
diff --git a/algorithm/src/main/java/dataStructureDesign/MaximumFrequencyStack.java b/algorithm/src/main/java/dataStructureDesign/MaximumFrequencyStack.java
new file mode 100644
index 0000000..200e28c
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/MaximumFrequencyStack.java
@@ -0,0 +1,48 @@
+package dataStructureDesign;
+
+import java.util.HashMap;
+import java.util.PriorityQueue;
+import java.util.Stack;
+
+/**
+ *  895 最大频率栈
+ */
+
+
+public class MaximumFrequencyStack {
+
+    // 当前最大频率
+    int maxFre = 0;
+
+    // 数值与频率的映射表
+    HashMap<Integer, Integer> valToFre = new HashMap<>();
+    // 频率与数值的映射表
+    HashMap<Integer, Stack<Integer>> freToVal = new HashMap<Integer, Stack<Integer>>();
+
+
+    public void push(int val) {
+        // 修改 VF 表：val 对应的 freq 加⼀
+        int fre = valToFre.getOrDefault(val, 0) + 1;
+        valToFre.put(val, fre);
+        // 修改 FV 表：在 freq 对应的列表加上 val
+        freToVal.putIfAbsent(fre, new Stack<>());
+        freToVal.get(fre).push(val);
+        // 更新 maxFreq
+        maxFre = Math.max(maxFre, fre);
+
+    }
+
+    public int pop() {
+        Stack<Integer> vals = freToVal.get(maxFre);
+        int v = vals.pop();
+        valToFre.replace(v, maxFre-1);
+        if(vals.isEmpty()) {
+            maxFre--;
+            freToVal.remove(maxFre);
+        }
+        return v;
+    }
+
+}
+
+
diff --git a/algorithm/src/main/java/dataStructureDesign/MinStack.java b/algorithm/src/main/java/dataStructureDesign/MinStack.java
new file mode 100644
index 0000000..abd5fb0
--- /dev/null
+++ b/algorithm/src/main/java/dataStructureDesign/MinStack.java
@@ -0,0 +1,36 @@
+package dataStructureDesign;
+
+import java.util.Stack;
+
+/**
+ * 155 最小栈
+ */
+
+public class MinStack {
+
+    Stack<Integer> stack1 = new Stack<>();
+    Stack<Integer> stack2 = new Stack<>();
+
+    void push(int val) {
+        if(stack1.isEmpty()) {
+            stack2.push(val);
+        }else {
+            int minVal = Math.min(stack2.peek(), val);
+            stack2.push(minVal);
+        }
+        stack1.push(val);
+    }
+
+    void pop() {
+        stack1.pop();
+        stack2.pop();
+    }
+
+    int top() {
+        return stack1.peek();
+    }
+
+    int getMin() {
+        return stack2.peek();
+    }
+}
diff --git a/algorithm/src/main/java/differenceArray/CarPooling.java b/algorithm/src/main/java/differenceArray/CarPooling.java
new file mode 100644
index 0000000..c417772
--- /dev/null
+++ b/algorithm/src/main/java/differenceArray/CarPooling.java
@@ -0,0 +1,38 @@
+package differenceArray;
+
+/**
+ * 1094. 拼车
+ * 公交站台数量不多于1000个
+ */
+
+public class CarPooling {
+
+    public boolean carPooling(int[][] trips, int capacity) {
+        if(trips.length==0) {
+            return true;
+        }
+        boolean res = true;
+
+        // 初始化差分数组
+        int[] diff = new int[1001];
+
+        // 对差分数组进行操作
+        for(int i=0;i<trips.length;i++) {
+            int left = trips[i][1];
+            int right = trips[i][2];
+            int value = trips[i][0];
+            diff[left] += value;
+            diff[right+1] -= value;
+        }
+
+        // 计算结果数组
+        for(int i=1;i<diff.length;i++) {
+            diff[i] += diff[i-1];
+            if(diff[i]>capacity) {
+                res = false;
+                break;
+            }
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/differenceArray/FlightBooking.java b/algorithm/src/main/java/differenceArray/FlightBooking.java
new file mode 100644
index 0000000..830e398
--- /dev/null
+++ b/algorithm/src/main/java/differenceArray/FlightBooking.java
@@ -0,0 +1,32 @@
+package differenceArray;
+
+/**
+ * 1109. 航班预订统计
+ */
+
+public class FlightBooking {
+
+    int[] flightBooking(int[][] bookings, int n) {
+
+        int[] diff = new int[n];
+
+        // 初始化差分数组
+        for(int i=0;i<bookings.length;i++) {
+            int left = bookings[i][0];
+            int right = bookings[i][1];
+            int value = bookings[i][2];
+            diff[left-1] += value;
+            // 在区间范围内的进行操作
+            if(right<n) {
+                diff[right] -= value;
+            }
+        }
+
+        // 计算结果
+        for(int i=1;i<diff.length;i++) {
+            diff[i] += diff[i-1];
+        }
+
+        return diff;
+    }
+}
diff --git a/algorithm/src/main/java/differenceArray/RangeAdd.java b/algorithm/src/main/java/differenceArray/RangeAdd.java
new file mode 100644
index 0000000..198f8f1
--- /dev/null
+++ b/algorithm/src/main/java/differenceArray/RangeAdd.java
@@ -0,0 +1,36 @@
+package differenceArray;
+
+/**
+ * 370. 区间加法
+ */
+
+public class RangeAdd {
+
+    public int[] rangeAdd(int[][] updates, int length) {
+        int[] diff = new int[length];
+
+        // 差分数组初始化
+        for(int i=0;i<updates.length;i++) {
+            int left = updates[i][0];
+            int right = updates[i][1];
+            int value = updates[i][2];
+            diff[left] += value;
+            if(right+1<diff.length) {
+                diff[right+1] -= value;
+            }
+        }
+
+        for(int i=1;i<diff.length;i++) {
+            diff[i] += diff[i-1];
+        }
+
+
+        // 计算结果
+
+
+
+        return diff;
+    }
+}
+
+
diff --git a/algorithm/src/main/java/graphTheory/AllPathList.java b/algorithm/src/main/java/graphTheory/AllPathList.java
new file mode 100644
index 0000000..5a56486
--- /dev/null
+++ b/algorithm/src/main/java/graphTheory/AllPathList.java
@@ -0,0 +1,46 @@
+package graphTheory;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 797. All Paths From Source to Target 797. 所有可能的路径 �
+ */
+
+public class AllPathList {
+
+    // 记录所有路径
+    List<List<Integer>> res = new LinkedList<>();
+
+    public List<List<Integer>> allPathResourceTarget(int[][] graph) {
+        LinkedList<Integer> path = new LinkedList<>();
+        traverse(graph, 0, path);
+        return res;
+
+    }
+
+    // 图的遍历框架
+    private void traverse(int[][] graph, int s, LinkedList<Integer> path) {
+
+        // 添加节点 s 到路径
+        path.addLast(s);
+
+        int n = graph.length;
+        if(s == n-1) {
+            // 到达终点
+            res.add(new LinkedList<>(path));
+            path.removeLast();
+            return;
+        }
+
+        // 递归每个相邻节点
+        for(int v: graph[s]) {
+            traverse(graph, v, path);
+        }
+
+        // 从路径移除节点 s
+        path.removeLast();
+    }
+
+}
diff --git a/algorithm/src/main/java/images/binary-tree-traversal.jpg b/algorithm/src/main/java/images/binary-tree-traversal.jpg
new file mode 100644
index 0000000..d5ec630
Binary files /dev/null and b/algorithm/src/main/java/images/binary-tree-traversal.jpg differ
diff --git a/algorithm/src/main/java/images/graph.jpg b/algorithm/src/main/java/images/graph.jpg
new file mode 100644
index 0000000..d9cabcd
Binary files /dev/null and b/algorithm/src/main/java/images/graph.jpg differ
diff --git a/algorithm/src/main/java/images/plugin4.png b/algorithm/src/main/java/images/plugin4.png
new file mode 100644
index 0000000..1687cda
Binary files /dev/null and b/algorithm/src/main/java/images/plugin4.png differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin1.png" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin1.png"
new file mode 100644
index 0000000..df98632
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin1.png" differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin2.png" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin2.png"
new file mode 100644
index 0000000..0524928
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221plugin2.png" differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\344\276\213\345\255\220.jpg" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\344\276\213\345\255\220.jpg"
new file mode 100644
index 0000000..2e654bc
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\344\276\213\345\255\220.jpg" differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\346\241\210\344\276\2132.png" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\346\241\210\344\276\2132.png"
new file mode 100644
index 0000000..d9bdafb
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\346\241\210\344\276\2132.png" differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\206.gif" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\206.gif"
new file mode 100644
index 0000000..44169dd
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\206.gif" differ
diff --git "a/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\2062.jpeg" "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\2062.jpeg"
new file mode 100644
index 0000000..5b05f85
Binary files /dev/null and "b/algorithm/src/main/java/images/\344\272\214\345\217\211\346\240\221\351\201\215\345\216\2062.jpeg" differ
diff --git "a/algorithm/src/main/java/images/\345\211\215\344\270\255\345\220\216\345\272\217\344\272\214\345\217\211\346\240\221.jpeg" "b/algorithm/src/main/java/images/\345\211\215\344\270\255\345\220\216\345\272\217\344\272\214\345\217\211\346\240\221.jpeg"
new file mode 100644
index 0000000..5b05f85
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\211\215\344\270\255\345\220\216\345\272\217\344\272\214\345\217\211\346\240\221.jpeg" differ
diff --git "a/algorithm/src/main/java/images/\345\211\215\345\272\217\345\220\216\347\273\255\351\201\215\345\216\206.jpeg" "b/algorithm/src/main/java/images/\345\211\215\345\272\217\345\220\216\347\273\255\351\201\215\345\216\206.jpeg"
new file mode 100644
index 0000000..7d7685a
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\211\215\345\272\217\345\220\216\347\273\255\351\201\215\345\216\206.jpeg" differ
diff --git "a/algorithm/src/main/java/images/\345\211\215\345\272\217\351\201\215\345\216\2062.jpeg" "b/algorithm/src/main/java/images/\345\211\215\345\272\217\351\201\215\345\216\2062.jpeg"
new file mode 100644
index 0000000..225bd37
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\211\215\345\272\217\351\201\215\345\216\2062.jpeg" differ
diff --git "a/algorithm/src/main/java/images/\345\217\215\350\275\254\351\223\276\350\241\2502.jpg" "b/algorithm/src/main/java/images/\345\217\215\350\275\254\351\223\276\350\241\2502.jpg"
new file mode 100644
index 0000000..ea20174
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\217\215\350\275\254\351\223\276\350\241\2502.jpg" differ
diff --git "a/algorithm/src/main/java/images/\345\233\276\350\256\272\350\241\250\347\244\272\346\226\271\346\263\225.jpeg" "b/algorithm/src/main/java/images/\345\233\276\350\256\272\350\241\250\347\244\272\346\226\271\346\263\225.jpeg"
new file mode 100644
index 0000000..99f954d
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\233\276\350\256\272\350\241\250\347\244\272\346\226\271\346\263\225.jpeg" differ
diff --git "a/algorithm/src/main/java/images/\345\272\246.jpg" "b/algorithm/src/main/java/images/\345\272\246.jpg"
new file mode 100644
index 0000000..d9cabcd
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\272\246.jpg" differ
diff --git "a/algorithm/src/main/java/images/\345\276\252\347\216\257\351\201\215\345\216\206.jpeg" "b/algorithm/src/main/java/images/\345\276\252\347\216\257\351\201\215\345\216\206.jpeg"
new file mode 100644
index 0000000..687364b
Binary files /dev/null and "b/algorithm/src/main/java/images/\345\276\252\347\216\257\351\201\215\345\216\206.jpeg" differ
diff --git "a/algorithm/src/main/java/linkedList/doublePointer/19 \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md" "b/algorithm/src/main/java/linkedList/doublePointer/19 \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
new file mode 100644
index 0000000..b82608b
--- /dev/null
+++ "b/algorithm/src/main/java/linkedList/doublePointer/19 \345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"	
@@ -0,0 +1,11 @@
+
+
+
+
+## 解题思路
+
+
+
+本题采用双指针来求解。其中`right-left=N+1`，这是本题的关键。
+
+当right到达末尾时，其值为null，那么需要删除的位置为`left+1`处，这时需要将left、left+2处连接起来。
\ No newline at end of file
diff --git "a/algorithm/src/main/java/linkedList/doublePointer/23 \345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md" "b/algorithm/src/main/java/linkedList/doublePointer/23 \345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md"
new file mode 100644
index 0000000..d61f7ab
--- /dev/null
+++ "b/algorithm/src/main/java/linkedList/doublePointer/23 \345\220\210\345\271\266K\344\270\252\345\215\207\345\272\217\351\223\276\350\241\250.md"	
@@ -0,0 +1,22 @@
+
+
+
+
+## 解题思路
+
+
+
+如果按照常规方法，使用指针去指向各个链表，那么无疑是计算量会很大的，因为会重复遍历。
+
+
+
+这题的关键点在于如何求得K个链表当前节点的最小值。只要求得了当前最小值，将其取出，然后再添加node.next即可。
+
+求K个值的最小值，可以使用PriorityQueue来求值。可以设定容量为K，即
+
+```java
+// 从小到大排列。优先级队列，最小堆，堆的容量等于链表的个数(K)
+        PriorityQueue<ListNode> pq = new PriorityQueue<>(
+                lists.length,(a,b) -> (a.val-b.val));
+```
+
diff --git a/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers.java b/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers.java
new file mode 100644
index 0000000..5e594fe
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers.java
@@ -0,0 +1,45 @@
+package linkedList.doublePointer;
+
+/*
+2. 两数相加
+ */
+
+public class AddTwoNumbers {
+
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        // 两个链表上的两个指针
+        ListNode p1 =l1 , p2=l2;
+
+        // 虚拟节点（构建新链表时的常用技巧）
+        ListNode dummy = new ListNode(-1);
+
+        // 负责构建新链表
+        ListNode p = dummy;
+
+        // 进位符号
+        int carry=0;
+
+        while(p1!=null || p2!=null || carry>0) {
+            int val = carry;
+            carry = 0;
+            if(p1!=null) {
+                val += p1.val;
+                p1 = p1.next;
+            }
+            if(p2!=null) {
+                val += p2.val;
+                p2 = p2.next;
+            }
+            if (val>9) {
+                val -= 10;
+                carry = 1;
+            }
+            p.next = new ListNode(val);
+            p = p.next;
+        }
+
+        return dummy.next;
+
+
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers2.java b/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers2.java
new file mode 100644
index 0000000..05e1054
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/AddTwoNumbers2.java
@@ -0,0 +1,89 @@
+package linkedList.doublePointer;
+
+/*
+2. 两数相加
+改编部分：采用顺序存储
+
+ */
+
+public class AddTwoNumbers2 {
+
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        // 对初始数据进行处理，使其从个位数开始
+        ListNode pre, next, curr = l1;
+        if(l1.next!=null) {
+            pre = l1;
+            next = l1.next;
+            pre.next = null;
+            while (next != null) {
+                curr = next;
+                next = next.next;
+                curr.next = pre;
+                pre = curr;
+            }
+            l1 = curr;
+        }
+
+        if(l2.next!=null) {
+            pre = l2;
+            next = l2.next;
+            pre.next = null;
+            while (next != null) {
+                curr = next;
+                next = next.next;
+                curr.next = pre;
+                pre = curr;
+            }
+            l2 = curr;
+        }
+
+
+        // 两个链表上的两个指针
+        ListNode p1 =l1 , p2=l2;
+
+        // 虚拟节点（构建新链表时的常用技巧）
+        ListNode dummy = new ListNode(-1);
+
+        // 负责构建新链表
+        ListNode p = dummy;
+
+        // 进位符号
+        int carry=0;
+
+        while(p1!=null || p2!=null || carry>0) {
+            int val = carry;
+            carry = 0;
+            if(p1!=null) {
+                val += p1.val;
+                p1 = p1.next;
+            }
+            if(p2!=null) {
+                val += p2.val;
+                p2 = p2.next;
+            }
+            if (val>9) {
+                val -= 10;
+                carry = 1;
+            }
+            p.next = new ListNode(val);
+            p = p.next;
+        }
+
+        // 对结果值进行处理
+        ListNode res = dummy.next;
+        if(res.next!=null) {
+            pre = res;
+            next = res.next;
+            pre.next = null;
+            while(next!=null) {
+                curr = next;
+                next = next.next;
+                curr.next = pre;
+                pre = curr;
+            }
+        }
+        return curr;
+
+
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/DeleteNthNode.java b/algorithm/src/main/java/linkedList/doublePointer/DeleteNthNode.java
new file mode 100644
index 0000000..db8f914
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/DeleteNthNode.java
@@ -0,0 +1,32 @@
+package linkedList.doublePointer;
+
+/**
+ * 19. 删除链表的倒数第 N 个结点 �
+ */
+
+public class DeleteNthNode {
+
+    public ListNode deleteNthNode(ListNode list, int n) {
+        ListNode slow = list, fast = list;
+
+        // 快指针先走 n 步
+        for(int i=0;i<=n;i++) {
+            if(fast==null) {
+                return list;
+            }
+            fast = fast.next;
+        }
+
+        // 快慢指针同时走，直到快指针到结尾处
+        while(fast!=null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+
+        if(slow.next!=null) {
+            slow.next = slow.next.next;
+        }
+
+        return list;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycle.java b/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycle.java
new file mode 100644
index 0000000..8be935f
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycle.java
@@ -0,0 +1,29 @@
+package linkedList.doublePointer;
+
+/**
+ * 141. 环形链表
+ * // 使用快慢指针解题
+ */
+
+public class LinkedListCycle {
+
+    public boolean linkedListCycle(ListNode l) {
+        if(l==null && l.next==null) {
+            return false;
+        }
+
+        ListNode slow=l,fast=l.next;
+        boolean cycle = false;
+
+        while(fast!=null && fast.next!=null) {
+            slow = slow.next;
+            fast = fast.next;
+            fast = fast.next;
+            if(slow==fast) {
+                cycle = true;
+                break;
+            }
+        }
+        return cycle;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycleII.java b/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycleII.java
new file mode 100644
index 0000000..e20d13e
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/LinkedListCycleII.java
@@ -0,0 +1,31 @@
+package linkedList.doublePointer;
+
+/**
+ * 142. 环形链表 II
+ * 这道题属于数学知识+快慢指针
+ */
+
+public class LinkedListCycleII {
+
+    public int linkedListCycle(ListNode l) {
+        int pos = -1;
+        ListNode slow=l, fast=l;
+        while(fast!=null && fast.next!=null) {
+            slow = slow.next;
+            fast = fast.next;
+            fast = fast.next;
+            if(slow==fast) {
+                pos = 0;
+                slow = l;
+                while(slow!=fast) {
+                    slow = slow.next;
+                    fast = fast.next;
+                    pos++;
+                    return pos;
+                }
+            }
+        }
+        return pos;
+    }
+
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/LinkedListIntersect.java b/algorithm/src/main/java/linkedList/doublePointer/LinkedListIntersect.java
new file mode 100644
index 0000000..9ae612e
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/LinkedListIntersect.java
@@ -0,0 +1,28 @@
+package linkedList.doublePointer;
+
+/**
+ * 160. 相交链表
+ */
+
+
+import linkedList.doublePointer.ListNode;
+
+public class LinkedListIntersect {
+
+    public ListNode intersect(ListNode l1, ListNode l2) {
+        ListNode p1=l1, p2=l2;
+        while(p1!=p2) {
+            if(p1==null) {
+                p1 = l2;
+            }else{
+                p1 = p1.next;
+            }
+            if(p2==null) {
+                p2 = l1;
+            }else{
+                p2 = p2.next;
+            }
+        }
+        return p1;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/ListNode.java b/algorithm/src/main/java/linkedList/doublePointer/ListNode.java
new file mode 100644
index 0000000..bbf8972
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/ListNode.java
@@ -0,0 +1,43 @@
+package linkedList.doublePointer;
+
+public class ListNode {
+    public int val;
+    public ListNode next;
+
+    ListNode() {}
+    public ListNode(int val) {
+        this.val = val;
+    }
+    ListNode(int val, ListNode next) {
+        this.val = val;
+        this.next = next;
+    }
+
+    public static ListNode numsToListNode(int[] nums) {
+        ListNode dummy = new ListNode(-1);
+        ListNode p=dummy;
+        for(int n: nums) {
+            p.next = new ListNode(n);
+            p = p.next;
+        }
+        return dummy.next;
+    }
+
+    public static int[] listNodeToNum(ListNode l) {
+        int size = 0;
+        ListNode p = l;
+        while(p!=null) {
+            size++;
+            p = p.next;
+        }
+
+        int[] nums = new int[size];
+        p = l;
+        for(int i=0;i<size;i++) {
+            nums[i] = p.val;
+            p = p.next;
+        }
+        return nums;
+    }
+
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/MergeKSortedList.java b/algorithm/src/main/java/linkedList/doublePointer/MergeKSortedList.java
new file mode 100644
index 0000000..b9591cb
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/MergeKSortedList.java
@@ -0,0 +1,36 @@
+package linkedList.doublePointer;
+
+import java.util.PriorityQueue;
+
+/**
+ * 23. 合并K个有序链表
+ */
+
+public class MergeKSortedList {
+
+    public ListNode mergeKListNode(ListNode[] lists) {
+        ListNode dummy = new ListNode(-1);
+        ListNode p = dummy;
+        // 从小到大排列。优先级队列，最小堆，堆的容量等于链表的个数(K)
+        PriorityQueue<ListNode> pq = new PriorityQueue<>(
+                lists.length,(a,b) -> (a.val-b.val));
+
+        for(ListNode header : lists) {
+            if(header!=null) {
+                pq.add(header);
+            }
+        }
+
+        while(!pq.isEmpty()) {
+            ListNode node = pq.poll();
+            p.next = node;
+            p = p.next;
+            if(node.next!=null) {
+                pq.add(node.next);
+            }
+        }
+
+        return dummy.next;
+
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/MergeSortedList.java b/algorithm/src/main/java/linkedList/doublePointer/MergeSortedList.java
new file mode 100644
index 0000000..6e30d58
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/MergeSortedList.java
@@ -0,0 +1,34 @@
+package linkedList.doublePointer;
+
+/**
+ * 21. 合并两个有序链表
+ */
+
+import linkedList.doublePointer.ListNode;
+
+public class MergeSortedList {
+
+    public ListNode mergeSortedList(ListNode l1, ListNode l2) {
+        ListNode p1=l1, p2=l2, dummy=new ListNode(-1);
+        ListNode p = dummy;
+        while(p1!=null || p2!=null) {
+            if(p1!=null && p2!=null) {
+                if(p1.val<p2.val) {
+                    p.next = p1;
+                    p1 = p1.next;
+                }else {
+                    p.next = p2;
+                    p2 = p2.next;
+                }
+                p = p.next;
+            }else if(p2==null) {
+                p.next = p1;
+                p1 = null;
+            }else if(p1==null) {
+                p.next = p2;
+                p2 = null;
+            }
+        }
+        return dummy.next;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/MiddleNode.java b/algorithm/src/main/java/linkedList/doublePointer/MiddleNode.java
new file mode 100644
index 0000000..d0993e7
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/MiddleNode.java
@@ -0,0 +1,21 @@
+package linkedList.doublePointer;
+
+/**
+ * 876 链表的中间节点
+ */
+
+public class MiddleNode {
+
+    public ListNode middleNode(ListNode list) {
+        if(list==null) {
+            return null;
+        }
+        ListNode slow=list, fast=list;
+
+        while(fast!=null && fast.next!=null) {
+            fast = fast.next.next;
+            slow = slow.next;
+        }
+        return slow;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/PalindromeLinkedList.java b/algorithm/src/main/java/linkedList/doublePointer/PalindromeLinkedList.java
new file mode 100644
index 0000000..3e3ba08
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/PalindromeLinkedList.java
@@ -0,0 +1,4 @@
+package linkedList.doublePointer;
+
+public class PalindromeLinkedList {
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/RemoveDuplicate.java b/algorithm/src/main/java/linkedList/doublePointer/RemoveDuplicate.java
new file mode 100644
index 0000000..e52845a
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/RemoveDuplicate.java
@@ -0,0 +1,21 @@
+package linkedList.doublePointer;
+
+/**
+ * 83. 删除排序链表中的重复元素
+ */
+
+public class RemoveDuplicate {
+
+    ListNode remove(ListNode head) {
+        ListNode slow=head, fast=head;
+        while(fast!=null) {
+            if(slow.val==fast.val) {
+                fast = fast.next;
+            } else {
+                slow.next = fast;
+                slow = fast;
+            }
+        }
+        return head;
+    }
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/ReverseLinkedListII.java b/algorithm/src/main/java/linkedList/doublePointer/ReverseLinkedListII.java
new file mode 100644
index 0000000..155d291
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/ReverseLinkedListII.java
@@ -0,0 +1,4 @@
+package linkedList.doublePointer;
+
+public class ReverseLinkedListII {
+}
diff --git a/algorithm/src/main/java/linkedList/doublePointer/ReverseNodesInKGroup.java b/algorithm/src/main/java/linkedList/doublePointer/ReverseNodesInKGroup.java
new file mode 100644
index 0000000..21a0337
--- /dev/null
+++ b/algorithm/src/main/java/linkedList/doublePointer/ReverseNodesInKGroup.java
@@ -0,0 +1,14 @@
+package linkedList.doublePointer;
+
+/**
+ * K个一组翻转链表
+ */
+
+public class ReverseNodesInKGroup {
+
+    public ListNode reverseNodesInKGroup(ListNode root) {
+        ListNode dummy = root;
+
+        return dummy.next;
+    }
+}
diff --git "a/algorithm/src/main/java/linkedList/doublePointer/\351\223\276\350\241\250+\345\217\214\346\214\207\351\222\210.md" "b/algorithm/src/main/java/linkedList/doublePointer/\351\223\276\350\241\250+\345\217\214\346\214\207\351\222\210.md"
new file mode 100644
index 0000000..0f46808
--- /dev/null
+++ "b/algorithm/src/main/java/linkedList/doublePointer/\351\223\276\350\241\250+\345\217\214\346\214\207\351\222\210.md"
@@ -0,0 +1,54 @@
+# 链表双指针
+
+
+
+[2. 两数相加](https://leetcode.cn/problems/add-two-numbers/)
+
+[160. 相交链表](https://leetcode.cn/problems/intersection-of-two-linked-lists/)
+
+
+
+
+
+
+
+
+
+
+
+
+
+### 优先级队列
+
+[21. 合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists/)
+
+[23. 合并K个升序链表](https://leetcode.cn/problems/merge-k-sorted-lists/)
+
+
+
+### 快慢指针
+
+[141. 环形链表](https://leetcode.cn/problems/linked-list-cycle/)
+
+[142. 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii/)
+
+[19. 删除链表的倒数第 N 个结点](https://leetcode.cn/problems/remove-nth-node-from-end-of-list/)
+
+[876. 链表的中间结点](https://leetcode.cn/problems/middle-of-the-linked-list/)
+
+[83. 删除排序链表中的重复元素](https://leetcode.cn/problems/remove-duplicates-from-sorted-list/)
+
+
+
+```java
+// 查找中间节点,第(N+1)/2位置
+ListNode slow=head, fast=head;
+While(fast!=null && fast.next!=null) {
+    slow = slow.next;
+    fast = fast.next.next;  
+}
+```
+
+
+
+删除第N个节点，可以先让快指针走`N-1`步，然后删除
\ No newline at end of file
diff --git a/algorithm/src/main/java/multiThread/FizzBuzz.java b/algorithm/src/main/java/multiThread/FizzBuzz.java
new file mode 100644
index 0000000..d8ec308
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/FizzBuzz.java
@@ -0,0 +1,91 @@
+package multiThread;
+
+import java.util.Scanner;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 1195 交替打印字符串
+ */
+
+public class FizzBuzz {
+    int order=0; // fizzbuzz=0, fizz=1, buzz=2, number=3;
+    ReentrantLock lock = new ReentrantLock();
+    int state=1;
+    int count;
+
+
+    public FizzBuzz(int n) {
+        count = n;
+    }
+
+    public void fizzbuzz() {
+        while(state<=count) {
+            lock.lock();
+            if(state<=count && order==0 && state%15==0) {
+                System.out.print(",fizzbuzz");
+                state++;
+                order=0;
+            }else {
+                order = 1;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void fizz() {
+        while(state<=count) {
+            lock.lock();
+            if(state<=count && order==1 && state%3==0) {
+                System.out.print(",fizz");
+                state++;
+                order=0;
+            }else {
+                order = 2;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void buzz() {
+        while(state<=count) {
+            lock.lock();
+            if(state<=count && order==2 && state%5==0) {
+                System.out.print(",buzz");
+                state++;
+                order=0;
+            }else {
+                order = 3;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void number() {
+        while(state<=count) {
+            lock.lock();
+            if(state<=count && order==3 && state%3!=0 && state%5!=0) {
+                if(state==1){
+                    System.out.print(state);
+                }else {
+                    System.out.print(","+state);
+                }
+                state++;
+
+            }
+            order=0;
+            lock.unlock();
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = Integer.parseInt(sc.nextLine().trim());
+        FizzBuzz obj = new FizzBuzz(n);
+
+        new Thread(obj::fizzbuzz).start();
+        new Thread(obj::fizz).start();
+        new Thread(obj::buzz).start();
+        new Thread(obj::number).start();
+    }
+
+}
diff --git a/algorithm/src/main/java/multiThread/FizzBuzzII.java b/algorithm/src/main/java/multiThread/FizzBuzzII.java
new file mode 100644
index 0000000..2bd2680
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/FizzBuzzII.java
@@ -0,0 +1,123 @@
+package multiThread;
+
+import java.util.Scanner;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+/**
+ * 1195 交替打印字符串
+ */
+
+
+class IntConsumer{
+    public void accept(int x) {
+        System.out.print(x);
+    }
+}
+
+public class FizzBuzzII {
+    int n;
+    int state=1;
+    CyclicBarrier cb = new CyclicBarrier(4);
+
+    public FizzBuzzII(int n) {
+        this.n = n;
+    }
+
+    public void fizz(Runnable printFizz) throws InterruptedException, BrokenBarrierException {
+        for(int i=1; i<=n; i++) {
+            if(i%3==0 && i%5!=0) {
+                printFizz.run();
+            }
+            cb.await();
+        }
+    }
+
+    public void buzz(Runnable printBuzz) throws InterruptedException, BrokenBarrierException {
+        for(int i=1;i<=n;i++) {
+            if(i%3!=0 && i%5==0) {
+                printBuzz.run();
+            }
+            cb.await();
+        }
+    }
+
+    public void fizzBuzz(Runnable printFizzBuzz) throws InterruptedException, BrokenBarrierException {
+        for(int i=1;i<=n;i++) {
+            if(i%15==0) {
+                printFizzBuzz.run();
+            }
+            cb.await();
+        }
+    }
+
+    public void number(IntConsumer printNumber) throws InterruptedException, BrokenBarrierException {
+        for(int i=1; i<=n; i++) {
+            if(i%3!=0 && i%5!=0) {
+                if(i!=1) {
+                    System.out.print(",");
+                }
+                printNumber.accept(i);
+            }
+            cb.await();
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = Integer.parseInt(sc.nextLine().trim());
+        FizzBuzzII obj = new FizzBuzzII(n);
+
+        new Thread(() ->{
+            try {
+                obj.fizz(new Runnable() {
+                    @Override
+                    public void run() {
+                        System.out.print(",fizz");
+                    }
+                });
+            } catch (InterruptedException | BrokenBarrierException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+        new Thread(() -> {
+            try {
+                obj.buzz(new Runnable() {
+                    @Override
+                    public void run() {
+                        System.out.print(",buzz");
+                    }
+                });
+            } catch (InterruptedException | BrokenBarrierException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+
+        new Thread(() -> {
+            try {
+                obj.fizzBuzz(new Runnable() {
+                    @Override
+                    public void run() {
+                        System.out.print(",fizzbuzz");
+                    }
+                });
+            } catch (InterruptedException | BrokenBarrierException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+        new Thread(() -> {
+            try {
+                obj.number(new IntConsumer());
+            } catch (InterruptedException | BrokenBarrierException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+    }
+
+
+
+}
diff --git a/algorithm/src/main/java/multiThread/FizzBuzzIII.java b/algorithm/src/main/java/multiThread/FizzBuzzIII.java
new file mode 100644
index 0000000..59de1c7
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/FizzBuzzIII.java
@@ -0,0 +1,103 @@
+package multiThread;
+
+import java.util.Scanner;
+import java.util.concurrent.Semaphore;
+
+
+
+/**
+ * 1195 交替打印字符串
+ */
+
+public class FizzBuzzIII {
+    int n;
+    public Semaphore number = new Semaphore(1);
+    public Semaphore fizz = new Semaphore(0);
+    public Semaphore buzz = new Semaphore(0);
+    public Semaphore fizzBuzz = new Semaphore(0);
+
+    public FizzBuzzIII(int n) {
+        this.n = n;
+    }
+
+    public void printFizz() throws InterruptedException {
+        for(int i=1; i<=n; i++) {
+            fizz.acquire();
+            if(i%3==0 && i%5!=0) {
+                System.out.print("fizz ");
+            }
+            buzz.release();
+        }
+    }
+
+    public void printBuzz() throws InterruptedException {
+        for(int i=1; i<=n; i++) {
+            buzz.acquire();
+            if(i%3!=0 && i%5==0) {
+                System.out.print("buzz ");
+            }
+            fizzBuzz.release();
+        }
+    }
+
+    public void printFizzBuzz() throws InterruptedException {
+        for(int i=1; i<=n;i++) {
+            fizzBuzz.acquire();
+            if(i%15==0) {
+                System.out.print("fizzbuzz ");
+            }
+            number.release();
+        }
+    }
+
+    public void printNumber() throws InterruptedException {
+        for(int i=1;i<=n;i++) {
+            number.acquire();
+            if(i%3!=0 && i%5!=0) {
+                System.out.print(i+" ");
+            }
+            fizz.release();
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = Integer.parseInt(sc.nextLine().trim());
+
+        FizzBuzzIII obj = new FizzBuzzIII(n);
+
+        new Thread(() -> {
+            try {
+                obj.printBuzz();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+        new Thread(() -> {
+            try {
+                obj.printFizz();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+        new Thread(() -> {
+            try {
+                obj.printFizzBuzz();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+        new Thread(() -> {
+            try {
+                obj.printNumber();
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+
+
+
+    }
+}
diff --git a/algorithm/src/main/java/multiThread/PrintFooBarAlternately.java b/algorithm/src/main/java/multiThread/PrintFooBarAlternately.java
new file mode 100644
index 0000000..d666897
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/PrintFooBarAlternately.java
@@ -0,0 +1,79 @@
+package multiThread;
+
+import java.util.Scanner;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ *  1115 交替打印FooBar
+ */
+
+public class PrintFooBarAlternately {
+
+    private int n;
+    ReentrantLock lock = new ReentrantLock();
+    int state=0;
+
+    public PrintFooBarAlternately(int n) {
+        this.n = n;
+    }
+
+    public Runnable printFoo() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("foo");
+            }
+        };
+    }
+
+    public Runnable printBar() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("bar");
+            }
+        };
+    }
+
+    public void foo(Runnable printFoo) {
+        for(int i=0;i<n;i++) {
+            lock.lock();
+            if(state%2==0) {
+                printFoo.run();
+                state++;
+            }else{
+                i--;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void bar(Runnable printBar) {
+        for(int i=0;i<n;i++) {
+            lock.lock();
+            if(state%2==1) {
+                printBar.run();
+                state++;
+            }else {
+                i--;
+            }
+            lock.unlock();
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = Integer.parseInt(sc.nextLine().trim());
+
+        PrintFooBarAlternately print = new PrintFooBarAlternately(n);
+
+        new Thread(() -> {
+            print.foo(print.printFoo());
+        }).start();
+
+        new Thread(() -> {
+            print.bar(print.printBar());
+        }).start();
+
+    }
+}
diff --git a/algorithm/src/main/java/multiThread/PrintInOrder.java b/algorithm/src/main/java/multiThread/PrintInOrder.java
new file mode 100644
index 0000000..0519970
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/PrintInOrder.java
@@ -0,0 +1,117 @@
+package multiThread;
+
+
+
+
+import org.apache.commons.lang3.time.StopWatch;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 1114 按序打印
+ * 使用可重入锁 ReentrantLock
+ */
+
+
+
+public class PrintInOrder {
+
+    int state = 0;
+    ReentrantLock lock = new ReentrantLock();
+
+
+    public PrintInOrder() {
+    }
+
+    public Runnable printFirst() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("first");
+            }
+        };
+    }
+
+    public Runnable printSecond() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("second");
+            }
+        };
+    }
+
+    public Runnable printThird() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("third");
+            }
+        };
+    }
+
+    public void first(Runnable printFirst) {
+        lock.lock();
+        printFirst.run();
+        state++;
+        lock.unlock();
+
+    }
+
+    public void second(Runnable printSecond) {
+        while(state!=1) {}
+        lock.lock();
+        printSecond.run();
+        state++;
+        lock.unlock();
+    }
+
+
+
+    public void third(Runnable printThird) {
+        while (state != 2) {}
+        lock.lock();
+        printThird.run();
+        state++;
+        lock.unlock();
+    }
+
+
+    public static void main(String[] args) throws InterruptedException {
+        PrintInOrder foo = new PrintInOrder();
+
+        Thread thread1 =  new Thread(() -> {
+            foo.first(foo.printFirst());
+        });
+
+        Thread thread2 = new Thread(() -> {
+            foo.second(foo.printSecond());
+        });
+
+        Thread thread3 = new Thread(() -> {
+            foo.third(foo.printThird());
+        });
+
+        // 使用apache.commons的SopWatch计算程序耗时
+        StopWatch watch = new StopWatch();
+        watch.start();
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+
+        // 让程序依次执行完成
+        thread1.join();
+        thread2.join();
+        thread3.join();
+
+        watch.stop();
+        System.out.println("cost time: "+ watch.getTime()+"ms"); // 6ms
+
+
+
+
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/multiThread/PrintInOrder2.java b/algorithm/src/main/java/multiThread/PrintInOrder2.java
new file mode 100644
index 0000000..f96865b
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/PrintInOrder2.java
@@ -0,0 +1,107 @@
+package multiThread;
+
+        import org.apache.commons.lang3.time.StopWatch;
+
+        import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * 1114 按序打印
+ *
+ * 使用synchronized锁
+ */
+
+
+
+public class PrintInOrder2 {
+
+    int state = 0;
+//    ReentrantLock lock = new ReentrantLock();
+
+
+    public PrintInOrder2() {
+    }
+
+    public Runnable printFirst() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("first");
+            }
+        };
+    }
+
+    public Runnable printSecond() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("second");
+            }
+        };
+    }
+
+    public Runnable printThird() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("third");
+            }
+        };
+    }
+
+    public void first(Runnable printFirst) {
+        synchronized (this) {
+            printFirst.run();
+            state++;
+        }
+
+    }
+
+    public void second(Runnable printSecond) {
+        while(state!=1) {}
+        synchronized (this) {
+            printSecond.run();
+            state++;
+        }
+    }
+
+
+
+    public void third(Runnable printThird) {
+        while (state != 2) {}
+        synchronized (this) {
+            printThird.run();
+            state++;
+        }
+    }
+
+
+    public static void main(String[] args) throws InterruptedException {
+        PrintInOrder2 foo = new PrintInOrder2();
+
+        Thread thread1 =  new Thread(() -> {
+            foo.first(foo.printFirst());
+        });
+
+        Thread thread2 = new Thread(() -> {
+            foo.second(foo.printSecond());
+        });
+
+        Thread thread3 = new Thread(() -> {
+            foo.third(foo.printThird());
+        });
+
+        StopWatch watch = new StopWatch();
+        watch.start();
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+
+        thread1.join();
+        thread2.join();
+        thread3.join();
+
+        watch.stop();
+        System.out.println("cost time: " + watch.getTime()+"ms"); // 5ms
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/multiThread/PrintInOrder3.java b/algorithm/src/main/java/multiThread/PrintInOrder3.java
new file mode 100644
index 0000000..ca3948d
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/PrintInOrder3.java
@@ -0,0 +1,100 @@
+package multiThread;
+
+import org.apache.commons.lang3.time.StopWatch;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 1114 按序打印
+ *
+ * 使用synchronized锁
+ */
+
+
+
+public class PrintInOrder3 {
+
+    AtomicInteger state = new AtomicInteger(0);
+//    ReentrantLock lock = new ReentrantLock();
+
+
+    public PrintInOrder3() {
+    }
+
+    public Runnable printFirst() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("first");
+            }
+        };
+    }
+
+    public Runnable printSecond() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("second");
+            }
+        };
+    }
+
+    public Runnable printThird() {
+        return new Runnable() {
+            @Override
+            public void run() {
+                System.out.print("third");
+            }
+        };
+    }
+
+    public void first(Runnable printFirst) {
+            printFirst.run();
+            state.incrementAndGet();
+
+    }
+
+    public void second(Runnable printSecond) {
+        while(state.get()!=1) {}
+        printSecond.run();
+        state.incrementAndGet();
+    }
+
+
+
+    public void third(Runnable printThird) {
+        while (state.get() != 2) {}
+        printThird.run();
+        state.incrementAndGet();
+    }
+
+
+    public static void main(String[] args) throws InterruptedException {
+        PrintInOrder3 foo = new PrintInOrder3();
+
+        Thread thread1 =  new Thread(() -> {
+            foo.first(foo.printFirst());
+        });
+
+        Thread thread2 = new Thread(() -> {
+            foo.second(foo.printSecond());
+        });
+
+        Thread thread3 = new Thread(() -> {
+            foo.third(foo.printThird());
+        });
+        StopWatch watch = new StopWatch();
+        watch.start();
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+
+        thread1.join();
+        thread2.join();
+        thread3.join();
+
+        watch.stop();
+        System.out.println("cost time: "+watch.getTime()+"ms"); // 7ms
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/multiThread/PrintZeroOddEven.java b/algorithm/src/main/java/multiThread/PrintZeroOddEven.java
new file mode 100644
index 0000000..0f4794f
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/PrintZeroOddEven.java
@@ -0,0 +1,68 @@
+package multiThread;
+
+import java.util.Scanner;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ *  1115 打印零和奇偶数
+ */
+
+public class PrintZeroOddEven {
+    private int n;
+    int state=1;
+    boolean zeroState=true;
+    ReentrantLock lock = new ReentrantLock();
+
+    public PrintZeroOddEven(int n) {
+        this.n = n;
+    }
+
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void zero() {
+        while(state<=2*n) {
+            lock.lock();
+            if(state<=2*n && zeroState) {
+                System.out.print(0);
+                zeroState=false;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void even() {
+        while(state<=2*n) {
+            lock.lock();
+            if(state<=2*n && !zeroState && state%2==0) {
+                System.out.print(state);
+                zeroState=true;
+                state++;
+            }
+            lock.unlock();
+        }
+    }
+
+    public void odd(){
+        while(state<=2*n) {
+            lock.lock();
+            if(state<=2*n && !zeroState && state%2==1) {
+                System.out.print(state);
+                zeroState=true;
+                state++;
+            }
+            lock.unlock();
+        }
+
+    }
+
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        int n = Integer.parseInt(sc.nextLine().trim());
+        PrintZeroOddEven obj = new PrintZeroOddEven(n);
+        new Thread(obj::zero).start();
+
+        new Thread(obj::odd).start();
+
+        new Thread(obj::even).start();
+
+    }
+}
diff --git a/algorithm/src/main/java/multiThread/ProduceH2O.java b/algorithm/src/main/java/multiThread/ProduceH2O.java
new file mode 100644
index 0000000..fa41970
--- /dev/null
+++ b/algorithm/src/main/java/multiThread/ProduceH2O.java
@@ -0,0 +1,30 @@
+package multiThread;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ProduceH2O {
+
+    String water;
+    int state=0;
+    ReentrantLock lock = new ReentrantLock();
+
+    public ProduceH2O(String water) {
+        this.water = water;
+    }
+
+    public void hydrogen() {
+        while(state<water.length()) {
+            lock.lock();
+
+            lock.unlock();
+        }
+    }
+
+    public void oxygen() {
+
+    }
+
+    public static void main(String[] args) {
+
+    }
+}
diff --git a/algorithm/src/main/java/nSum/NSum.java b/algorithm/src/main/java/nSum/NSum.java
new file mode 100644
index 0000000..7aab538
--- /dev/null
+++ b/algorithm/src/main/java/nSum/NSum.java
@@ -0,0 +1,53 @@
+package nSum;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class NSum {
+
+    ArrayList<ArrayList<Integer>> nSum(int[] nums, int target, int N) {
+        Arrays.sort(nums);
+        return nSumHelper(nums, target, N, 0);
+    }
+
+    // 在这里，N大于2
+    ArrayList<ArrayList<Integer>> nSumHelper(int[] nums, int target, int N, int start){
+        // 小于两个数相加 或者 起点到终点的元素个数小于N
+        if(N<2 || start+N>nums.length) {
+            return new ArrayList<ArrayList<Integer>>();
+        }
+        else if(N==2) {
+            int low=start, high=nums.length-1;
+            ArrayList<ArrayList<Integer>> twoRes = new ArrayList<ArrayList<Integer>>();
+            while(low<high) {
+                if(nums[low]+nums[high]<target) {
+                    low++;
+                }else if(nums[low]+nums[high]>target) {
+                    high--;
+                }else {
+                    ArrayList<Integer> temp = new ArrayList<Integer>();
+                    temp.add(nums[low]);
+                    temp.add(nums[high]);
+                    twoRes.add(temp);
+                    int origin = nums[low];
+                    low++;
+                    while(origin==nums[low] && low<high) {
+                        low++;
+                    }
+                }
+            }
+            return twoRes;
+        }else {
+            ArrayList<ArrayList<Integer>> part = nSumHelper(nums, target - nums[start], N - 1, start+1);
+            if (part.size() > 0) {
+                for (ArrayList<Integer> integers : part) {
+                    integers.add(0, nums[start]);
+                }
+            }
+            return part;
+
+            }
+    }
+
+
+}
diff --git a/algorithm/src/main/java/nSum/ThreeSum.java b/algorithm/src/main/java/nSum/ThreeSum.java
new file mode 100644
index 0000000..1b9ebce
--- /dev/null
+++ b/algorithm/src/main/java/nSum/ThreeSum.java
@@ -0,0 +1,51 @@
+package nSum;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class ThreeSum {
+
+    // 规定遍历的起点，防止出现重复计算
+    // 在这里假设已经排号序了，从小到大
+    private ArrayList<ArrayList<Integer>> twoSum(int[] nums, int target, int start) {
+        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
+        int low = start;
+        int high = nums.length-1;
+        while(low<high) {
+            if(nums[low]+nums[high]<target) {
+                low++;
+            }else if(nums[low]+nums[high]>target) {
+                high--;
+            }else {
+                ArrayList<Integer> tempList = new ArrayList<Integer>();
+                tempList.add(nums[low]);
+                tempList.add(nums[high]);
+                res.add(tempList);
+                int temp = nums[low];
+                low++;
+                while(temp==nums[low] && low<high) {
+                    low++;
+                }
+            }
+        }
+        return res;
+    }
+
+    ArrayList<ArrayList<Integer>> threeSum(int[] nums, int target){
+        Arrays.sort(nums);
+        ArrayList<ArrayList<Integer>> res= new ArrayList<ArrayList<Integer>>();
+        for(int i=0;i<nums.length;i++) {
+
+            ArrayList<ArrayList<Integer>> part = twoSum(nums, target-nums[i], i+1);
+            if(part.size()>0) {
+                for(int j=0;i<part.size();i++){
+                    ArrayList<Integer> temp = new ArrayList<Integer>();
+                    part.get(j).add(0, nums[i]);
+                    res.add(part.get(j));
+                }
+            }
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/nSum/TwoSum.java b/algorithm/src/main/java/nSum/TwoSum.java
new file mode 100644
index 0000000..c1b9177
--- /dev/null
+++ b/algorithm/src/main/java/nSum/TwoSum.java
@@ -0,0 +1,60 @@
+package nSum;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * 1. 输入的数据为整形，顺序随机
+ * 2.
+ */
+
+public class TwoSum {
+    public ArrayList<ArrayList<Integer>> twoSum(int[] nums, int target) {
+        // 对数组进行排序，默认从小到大排序
+        // 如果需要降序，那么添加Collections.reverseOrder()属性
+        Arrays.sort(nums);
+        int low=0, high=nums.length-1;
+//        System.out.println(nums.length); // 4
+        ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
+        while(low<high) {
+
+            if(nums[low]+nums[high]<target) {
+                low++;
+            }else if(nums[low]+nums[high]>target) {
+                high--;
+
+                // 相等时存储
+            }else {
+                ArrayList<Integer> temp = new ArrayList<Integer>();
+                temp.add(nums[low]);
+                temp.add(nums[high]);
+                list.add(temp);
+                int origin = nums[low];
+                low++;
+                while(origin == nums[low] && low<high) {
+                    low++;
+                }
+            }
+        }
+
+        return list;
+    }
+
+    public static void main(String[] args) {
+        TwoSum solution = new TwoSum();
+        int[] nums = new int[] {1,3,5,2};
+       ArrayList<ArrayList<Integer>> res = solution.twoSum(nums, 5);
+        for(int i=0;i<res.size();i++) {
+            System.out.print("[");
+            for(int j=0;j<res.get(i).size();j++) {
+                System.out.print(res.get(i).get(j)+" ");
+            }
+            System.out.print("]\t");
+        }
+        System.out.println();
+    }
+
+}
+
+
+
diff --git a/algorithm/src/main/java/other/IsIsomorphic.java b/algorithm/src/main/java/other/IsIsomorphic.java
new file mode 100644
index 0000000..488681f
--- /dev/null
+++ b/algorithm/src/main/java/other/IsIsomorphic.java
@@ -0,0 +1,40 @@
+package other;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+/**
+ * 205 同构字符串
+ */
+
+public class IsIsomorphic {
+
+    public boolean isIsomorphic(String s, String t) {
+        HashMap<Character, Character> map = new HashMap<Character, Character>();
+        HashSet<Character> visited = new HashSet<>();
+        int p=0;
+        while(p<s.length()){
+            char c1 = s.charAt(p);
+            char c2 = t.charAt(p);
+
+            // s --> t
+            // 之前有映射值与当前值不同
+            if(map.containsKey(c1) && map.get(c1)!=c2){
+                return false;
+            }
+
+            // 当前没有映射值，但映射的目标值已经存在，即多个起点映射到一个终点
+            if(!map.containsKey(c1) && visited.contains(c2)){
+                return false;
+            }
+
+            if(!map.containsKey(c1)) {
+                map.put(c1, c2);
+                visited.add(c2);
+            }
+
+            p++;
+        }
+        return true;
+    }
+}
diff --git a/algorithm/src/main/java/prefixSum/MatrixSum.java b/algorithm/src/main/java/prefixSum/MatrixSum.java
new file mode 100644
index 0000000..a780522
--- /dev/null
+++ b/algorithm/src/main/java/prefixSum/MatrixSum.java
@@ -0,0 +1,33 @@
+package prefixSum;
+
+/**
+ * 1314. 矩阵区域和
+ */
+
+public class MatrixSum {
+
+
+    public int[][] matrixSum(int[][] matrix, int k) {
+        // 计算矩阵和
+        int[][] sum = new int[matrix.length+1][matrix[0].length+1];
+        for(int i=0;i<matrix.length;i++) {
+            for(int j=0;j<matrix[0].length;j++) {
+                sum[i+1][j+1] = matrix[i][j]+sum[i+1][j]+sum[i][j+1]-sum[i][j];
+            }
+        }
+
+        int[][] res = new int[matrix.length][matrix[0].length];
+
+        for(int i=0;i<matrix.length;i++) {
+            for(int j=0;j<matrix[0].length;j++) {
+                int row1 = Math.max(0, i-k);
+                int col1 = Math.max(0, j-k);
+                int row2 = Math.min(matrix.length-1, i+k);
+                int col2 = Math.min(matrix[0].length-1, j+k);
+                res[i][j] = sum[row2+1][col2+1] + sum[row1][col1]
+                            - sum[row1][col2+1] - sum[row2+1][col1];
+            }
+        }
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/prefixSum/NumArray.java b/algorithm/src/main/java/prefixSum/NumArray.java
new file mode 100644
index 0000000..97405af
--- /dev/null
+++ b/algorithm/src/main/java/prefixSum/NumArray.java
@@ -0,0 +1,48 @@
+package prefixSum;
+
+/**
+ * 303. 区域和检索 - 数组不可变
+ */
+
+/**
+ * 常规方法，每次都主次增加
+ */
+//public class NumArray {
+//    private int[] nums;
+//
+//    public NumArray(int [] nums) {
+//        this.nums = nums;
+//    }
+//
+//
+//    public int sumRange(int left, int right) {
+//        int sum = 0;
+//        for(int i=left;i<=right && i<nums.length;i++) {
+//            sum += nums[i];
+//        }
+//        return sum;
+//    }
+//}
+
+
+/**
+ * 累加数据
+ */
+public class NumArray {
+    private int[] nums;
+
+    public NumArray(int [] nums) {
+        this.nums = new int[nums.length+1];
+        this.nums[0] = 0;
+        for(int i=0;i<nums.length;i++) {
+            this.nums[i+1] = this.nums[i] + nums[i];
+        }
+    }
+
+
+    public int sumRange(int left, int right) {
+        if(left<0 || left>right || right>=nums.length-1)
+            return -1;
+        return nums[right+1]-nums[left];
+    }
+}
\ No newline at end of file
diff --git a/algorithm/src/main/java/prefixSum/NumMatrix.java b/algorithm/src/main/java/prefixSum/NumMatrix.java
new file mode 100644
index 0000000..8795f64
--- /dev/null
+++ b/algorithm/src/main/java/prefixSum/NumMatrix.java
@@ -0,0 +1,32 @@
+package prefixSum;
+
+/**
+ * 304. ⼆维区域和检索 - 矩阵不可变
+ */
+
+public class NumMatrix {
+
+    private int[][] matrix;
+
+    public NumMatrix(int[][] matrix) {
+
+        this.matrix = new int[matrix.length+1][matrix[0].length+1];
+        // 初始值为0
+//        System.out.println(matrix[0][0]);
+        for(int i=0;i<matrix.length;i++) {
+            for(int j=0;j<matrix[0].length;j++) {
+                this.matrix[i+1][j+1] = matrix[i][j] + this.matrix[i+1][j] + this.matrix[i][j+1]
+                        - this.matrix[i][j];
+//                System.out.println(""+(i)+", "+(j)+": "+this.matrix[i+1][j+1]);
+            }
+
+        }
+    }
+
+    int sumRegion(int row1, int col1, int row2, int col2) {
+        // 越界处理 略
+        // ...
+
+        return matrix[row2+1][col2+1]+matrix[row1][col1]-matrix[row1][col2+1]-matrix[row2+1][col1];
+    }
+}
diff --git a/algorithm/src/main/java/prefixSum/ProductOfNumbers.java b/algorithm/src/main/java/prefixSum/ProductOfNumbers.java
new file mode 100644
index 0000000..764d828
--- /dev/null
+++ b/algorithm/src/main/java/prefixSum/ProductOfNumbers.java
@@ -0,0 +1,39 @@
+package prefixSum;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 1352. 最后 K 个数的乘积
+ */
+
+public class ProductOfNumbers {
+
+    private List<Integer> list = new ArrayList<>();
+    private List<Integer> product = new ArrayList<>();
+
+    public ProductOfNumbers() {
+        // 标准操作
+        product.add(1);
+    }
+
+    public void add(int num) {
+        list.add(num);
+        if(num==0) {
+            product.clear();
+            product.add(1);
+        } else {
+            int res = product.get(product.size()-1)*num;
+            product.add(res);
+        }
+    }
+
+    public int getProduct(int k) {
+        if(k>=product.size()) {
+            return 0;
+        } else {
+            int n = product.size();
+            return product.get(n-1)/product.get(n-k-1);
+        }
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/EvalRPN.java b/algorithm/src/main/java/stack_queue/EvalRPN.java
new file mode 100644
index 0000000..0267637
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/EvalRPN.java
@@ -0,0 +1,41 @@
+package stack_queue;
+
+import java.util.Stack;
+
+/**
+ * 150. 逆波兰表达式求值
+ */
+
+public class EvalRPN {
+
+    int evalRPN(String[] tokens) {
+        Integer res;
+        Stack<Integer> stack = new Stack<>();
+        for(int i=0;i<tokens.length;i++) {
+            if(tokens[i].equals("+") || tokens[i].equals("-") ||
+                tokens[i].equals("*") || tokens[i].equals("/")) {
+                Integer num1 = stack.pop();
+                Integer num2 = stack.pop();
+                Integer temp;
+
+                if(tokens[i].equals("+")) {
+                    temp = num2 + num1;
+                } else if(tokens[i].equals("-")) {
+                    temp = num2 - num1;
+                } else if(tokens[i].equals("*")) {
+                    temp = num2 * num1;
+                } else {
+                    temp = num2 / num1;
+                 }
+                stack.push(temp);
+
+            } else {
+                Integer curr = Integer.valueOf(tokens[i]); // 将String转换成Integer
+                stack.push(curr);
+            }
+        }
+
+        res = stack.pop();
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/ImplementQueueUsingStacks.java b/algorithm/src/main/java/stack_queue/ImplementQueueUsingStacks.java
new file mode 100644
index 0000000..ca44950
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/ImplementQueueUsingStacks.java
@@ -0,0 +1,48 @@
+package stack_queue;
+
+import java.util.Stack;
+
+/**
+ * 232 用栈实现队列
+ */
+public class ImplementQueueUsingStacks {
+
+    private int peekValue=-1;
+    Stack<Integer> stack = new Stack<>();
+
+    void push(int x) {
+        if(stack.isEmpty()) {
+            peekValue = x;
+        }
+        stack.push(x);
+    }
+
+    int pop() {
+        Stack<Integer> temp = new Stack<>();
+        int sz = stack.size();
+        while (sz>2) {
+            temp.push(stack.pop());
+            sz--;
+        }
+        if(sz==2) {
+            peekValue = stack.peek();
+            temp.push(stack.pop());
+        }else {
+            peekValue = -1;
+        }
+        int res = stack.pop();
+
+        while (!temp.isEmpty()) {
+            stack.push(temp.pop());
+        }
+        return res;
+    }
+
+    int peek() {
+        return peekValue;
+    }
+
+    boolean empty() {
+        return stack.isEmpty();
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/ImplementStackUsingQueues.java b/algorithm/src/main/java/stack_queue/ImplementStackUsingQueues.java
new file mode 100644
index 0000000..70889ec
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/ImplementStackUsingQueues.java
@@ -0,0 +1,44 @@
+package stack_queue;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+/**
+ *  255 用队列实现栈
+ */
+
+public class ImplementStackUsingQueues {
+    private int peekValue=-1;
+    Queue<Integer> queue =new LinkedList<>();
+
+    void push(int x) {
+        queue.offer(x);
+        peekValue = x;
+    }
+
+    int pop() {
+        int sz = queue.size();
+        while (sz>2) {
+            queue.offer(queue.poll());
+            sz--;
+        }
+        if(sz==2) {
+            peekValue = queue.peek();
+            queue.offer(queue.poll());
+        }else {
+            peekValue = -1;
+        }
+        int res = queue.poll();
+        return res;
+    }
+
+    int peek() {
+        return peekValue;
+    }
+
+    boolean empty() {
+        return queue.isEmpty();
+    }
+
+}
diff --git a/algorithm/src/main/java/stack_queue/LongestValidParentheses.java b/algorithm/src/main/java/stack_queue/LongestValidParentheses.java
new file mode 100644
index 0000000..ed655a2
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/LongestValidParentheses.java
@@ -0,0 +1,40 @@
+package stack_queue;
+
+import java.util.Stack;
+
+/**
+ * 32. 最长有效括号
+ */
+
+public class LongestValidParentheses {
+
+    public int longestValidParentheses(String s) {
+        int res=0;
+        int[] dp = new int[s.length()+1];
+        Stack<Integer> stack = new Stack<>();
+        dp[0] = 0;
+
+        for(int i=0;i<s.length();i++) {
+            char c = s.charAt(i);
+            if(c=='(') {
+                stack.push(i); // 压入左括号索引
+                dp[i+1] = 0;
+            } else {
+                if(stack.empty()) {
+                    dp[i+1]=0;
+                } else {
+                    int index = stack.pop();
+                    dp[i+1] = i + 1 - index + dp[index];
+                }
+            }
+        }
+
+        for(int i=0;i<dp.length;i++) {
+            res = Math.max(res, dp[i]);
+        }
+
+        return res;
+    }
+
+
+}
diff --git a/algorithm/src/main/java/stack_queue/MinAddMakeValid.java b/algorithm/src/main/java/stack_queue/MinAddMakeValid.java
new file mode 100644
index 0000000..b8da236
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/MinAddMakeValid.java
@@ -0,0 +1,29 @@
+package stack_queue;
+
+/**
+ * 921. 使括号有效的最少添加
+ */
+
+
+public class MinAddMakeValid {
+
+    int minAddMakeValid(String s) {
+        int left=0, need=0;
+        for(int i=0;i<s.length();i++) {
+            char c = s.charAt(i);
+            if(c=='(') {
+                left++;
+            } else {
+                left--;
+            }
+
+            if(left<0) {
+                left=0;
+                need++;
+            }
+        }
+
+        return left+need;
+
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/MinStack.java b/algorithm/src/main/java/stack_queue/MinStack.java
new file mode 100644
index 0000000..b1500fb
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/MinStack.java
@@ -0,0 +1,41 @@
+package stack_queue;
+
+/**
+ * 155. 最⼩栈
+ */
+
+import java.util.Stack;
+
+public class MinStack {
+
+    private Stack<Integer> stack = new Stack<>();
+    private Stack<Integer> min = new Stack<>();
+
+    public MinStack() {
+
+    }
+
+    public void push(int val) {
+        stack.push(val);
+        if(min.isEmpty()) {
+            min.push(val);
+        } else {
+            Integer res = Math.min(min.peek(), val);
+            min.push(res);
+        }
+    }
+
+    public void pop() {
+        stack.pop();
+        min.pop();
+    }
+
+    public int top() {
+        return stack.peek();
+    }
+
+    public int getMin() {
+        return min.peek();
+    }
+
+}
diff --git a/algorithm/src/main/java/stack_queue/MinimumInsertionsToBalanceParentheses.java b/algorithm/src/main/java/stack_queue/MinimumInsertionsToBalanceParentheses.java
new file mode 100644
index 0000000..92cff2e
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/MinimumInsertionsToBalanceParentheses.java
@@ -0,0 +1,38 @@
+package stack_queue;
+
+import java.util.Queue;
+import java.util.Stack;
+
+/**
+ * 1541. 平衡括号字符串的最少插入次数
+ */
+public class MinimumInsertionsToBalanceParentheses {
+
+
+//    方法1
+    public int minInsert(String s){
+        int res=0, need=0;
+
+        for(int i=0;i<s.length();i++) {
+            char c = s.charAt(i);
+            if(c=='(') {
+                need+=2;
+                // 右括号为奇数，说明还需要添加一个右括号，让其为偶数，那么现在还需要need-1个右括号
+                if (need % 2 == 1) {
+                    res++;
+                    need--;
+                }
+            } else {
+                need--;
+                if(need==-1) {
+                    // 需要一个左括号时，那么添加一个左括号后，右括号还需要一个
+                    res++;
+                    need=1;
+                }
+            }
+        }
+
+        return need+res;
+    }
+
+}
diff --git a/algorithm/src/main/java/stack_queue/SimplifyPath.java b/algorithm/src/main/java/stack_queue/SimplifyPath.java
new file mode 100644
index 0000000..f654582
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/SimplifyPath.java
@@ -0,0 +1,42 @@
+package stack_queue;
+
+import jdk.nashorn.internal.ir.WhileNode;
+
+import java.util.Stack;
+
+/**
+ * 71. 简化路径。因为有回退操作，所以需要使用栈
+ */
+
+public class SimplifyPath {
+
+    public String simplifyPath(String path) {
+        String res = "";
+        String[] parts = path.split("/");
+        Stack<String> stack = new Stack<>();
+        for(String part: parts) {
+            if(part.isEmpty() || part.equals(".")) {
+                continue;
+            }
+            if(part.equals("..")) {
+                if(!stack.isEmpty()) {
+                    stack.pop();
+                }
+                continue;
+
+            } else {
+                stack.push(part);
+            }
+        }
+
+        while (!stack.isEmpty()) {
+            res = "/"+stack.pop()+res;
+        }
+
+        if(res.equals("")) {
+            res = "/";
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/SlidingWindowMax.java b/algorithm/src/main/java/stack_queue/SlidingWindowMax.java
new file mode 100644
index 0000000..fcabc4e
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/SlidingWindowMax.java
@@ -0,0 +1,55 @@
+package stack_queue;
+
+/**
+ * [239. 滑动窗口最大值]
+ */
+
+import java.util.LinkedList;
+
+class MonotonicQueue {
+    LinkedList<Integer> max = new LinkedList<Integer>();
+    int length;
+
+    public MonotonicQueue(int length) {
+        this.length = length;
+    }
+
+    public void push(Integer num) {
+        // 将⼩于 n 的元素全部删除
+        while (!max.isEmpty() && max.getLast() < num) {
+            max.pollLast(); // 从后往前删除
+        }
+        // 将数值加入尾部
+        max.addLast(num);
+
+        // 如果超过链表容量，则移除第一个元素
+        if (max.size() > length) {
+            max.removeFirst(); // 移除首元素
+        }
+    }
+
+    public int getMax() {
+        return max.getFirst();
+    }
+}
+
+public class SlidingWindowMax {
+
+    public int[] slidingWindowMax(int[] nums, int k) {
+        int[] res = new int[nums.length+1-k];
+        MonotonicQueue queue = new MonotonicQueue(k);
+
+        for(int i=0;i<nums.length;i++) {
+            //先填满窗⼝的前 k - 1
+            if(i<k-1) {
+                queue.push(nums[i]);
+                continue;
+            }
+            queue.push(nums[i]);
+            // 记录当前窗⼝的最⼤值
+            res[i+1-k]=queue.getMax();
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/main/java/stack_queue/ValidParentheses.java b/algorithm/src/main/java/stack_queue/ValidParentheses.java
new file mode 100644
index 0000000..39c8cc3
--- /dev/null
+++ b/algorithm/src/main/java/stack_queue/ValidParentheses.java
@@ -0,0 +1,35 @@
+package stack_queue;
+
+/**
+ * 20. 有效的括号
+ */
+
+import java.util.Stack;
+
+public class ValidParentheses {
+
+    public boolean validParentheses(String s) {
+        boolean res = true;
+        Stack<Character> stack = new Stack<>();
+        for(int i=0;i<s.length();i++) {
+            char c = s.charAt(i);
+            if(c=='[' || c=='(' || c=='{') {
+                stack.push(c);
+
+            } else {
+                if(stack.empty()) {
+                    res = false;
+                    break;
+                }
+
+                char pre = stack.pop();
+                if((pre=='[' && c!=']') || (pre=='(' && c!=')') || (pre=='{' && c!='}')) {
+                    res = false;
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.java b/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.java
new file mode 100644
index 0000000..478bdb4
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.java
@@ -0,0 +1,29 @@
+package BSF_DSF;
+
+import BFS_DFS.BinaryTreeLevelOrderTraversalII;
+import BFS_DFS.BinaryTreeZigzagLevelOrderTraversal;
+import binaryTree.TreeNode;
+import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class BinaryTreeLevelOrderTraversalIITest {
+
+    BinaryTreeLevelOrderTraversalII solver = new BinaryTreeLevelOrderTraversalII();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {3,9,30,-1,-1,15,7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        ArrayList<ArrayList<Integer>> res = solver.binaryTreeLevelOrderTraverseII(root);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [15, 7]
+             * [9, 30]
+             * [3]
+             */
+        }
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalTest.java b/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalTest.java
new file mode 100644
index 0000000..15e356a
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/BinaryTreeLevelOrderTraversalTest.java
@@ -0,0 +1,30 @@
+package BSF_DSF;
+
+import BFS_DFS.BinaryTreeLevelOrderTraversal;
+import binaryTree.TreeNode;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class BinaryTreeLevelOrderTraversalTest {
+
+    BinaryTreeLevelOrderTraversal solver = new BinaryTreeLevelOrderTraversal();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {3,9,20,-1,-1,15,7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        ArrayList<ArrayList<Integer>> res = solver.binaryTreeLevelOrderTraversal(root);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [
+             *  [3],
+             *  [9,20],
+             *  [15,7]
+             * ]
+             */
+        }
+
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.java b/algorithm/src/test/java/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.java
new file mode 100644
index 0000000..9d68f48
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.java
@@ -0,0 +1,61 @@
+package BSF_DSF;
+
+
+import BFS_DFS.BinaryTreeZigzagLevelOrderTraversal;
+import binaryTree.TreeNode;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class BinaryTreeZigzagLevelOrderTraversalTest {
+
+
+        BinaryTreeZigzagLevelOrderTraversal solver = new BinaryTreeZigzagLevelOrderTraversal();
+
+        @Test
+        public void testOne() {
+            int[] nums = new int[] {3, 9, 20, -1, -1, 15, 7};
+            TreeNode root = TreeNode.numsToTreeNode(nums);
+            ArrayList<ArrayList<Integer>> res = solver.binaryTreeZigzagLevelOrderTraversal(root);
+
+            for(ArrayList<Integer> t: res) {
+                System.out.println(t);
+                /**
+                 * [3]
+                 * [20, 9]
+                 * [15, 7]
+                 */
+        }
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = new int[] {3};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        ArrayList<ArrayList<Integer>> res = solver.binaryTreeZigzagLevelOrderTraversal(root);
+
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [3]
+             */
+        }
+    }
+
+    @Test
+    public void testThree() {
+        int[] nums = new int[] {};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        ArrayList<ArrayList<Integer>> res = solver.binaryTreeZigzagLevelOrderTraversal(root);
+
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * 空
+             */
+        }
+    }
+
+
+
+}
diff --git a/algorithm/src/test/java/BSF_DSF/CountSubIslandsTest.java b/algorithm/src/test/java/BSF_DSF/CountSubIslandsTest.java
new file mode 100644
index 0000000..d37ded1
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/CountSubIslandsTest.java
@@ -0,0 +1,53 @@
+package BSF_DSF;
+
+import BFS_DFS.CountSubIslands;
+import org.junit.Test;
+
+public class CountSubIslandsTest {
+    
+    CountSubIslands solver = new CountSubIslands();
+    
+    @Test
+    public void testOne() {
+        int[][] grid1 = new int[][]{
+                {1,1,1,0,0},
+                {0,1,1,1,1},
+                {0,0,0,0,0},
+                {1,0,0,0,0},
+                {1,1,0,1,1}
+        };
+        int[][] grid2 = new int[][]{
+                {1,1,1,0,0},
+                {0,0,1,1,1},
+                {0,1,0,0,0},
+                {1,0,1,1,0},
+                {0,1,0,1,0}
+        };
+
+        int res = solver.countSubIsland(grid1, grid2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] grid1 = new int[][]{
+                {1,0,1,0,1},
+                {1,1,1,1,1},
+                {0,0,0,0,0},
+                {1,1,1,1,1},
+                {1,0,1,0,1}
+        };
+        int[][] grid2 = new int[][]{
+                {0,0,0,0,0},
+                {1,1,1,1,1},
+                {0,1,0,1,0},
+                {0,1,0,1,0},
+                {1,0,0,0,1}
+        };
+
+        int res = solver.countSubIsland(grid1, grid2);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/MaxAreaIslandTest.java b/algorithm/src/test/java/BSF_DSF/MaxAreaIslandTest.java
new file mode 100644
index 0000000..34a70d3
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/MaxAreaIslandTest.java
@@ -0,0 +1,38 @@
+package BSF_DSF;
+
+import BFS_DFS.MaxAreaIsland;
+import org.junit.Test;
+
+public class MaxAreaIslandTest {
+
+    MaxAreaIsland solver = new MaxAreaIsland();
+
+    @Test
+    public void testOne() {
+        int[][] grid = {
+                {0,0,1,0,0,0,0,1,0,0,0,0,0},
+                {0,0,0,0,0,0,0,1,1,1,0,0,0},
+                {0,1,1,0,1,0,0,0,0,0,0,0,0},
+                {0,1,0,0,1,1,0,0,1,0,1,0,0},
+                {0,1,0,0,1,1,0,0,1,1,1,0,0},
+                {0,0,0,0,0,0,0,0,0,0,1,0,0},
+                {0,0,0,0,0,0,0,1,1,1,0,0,0},
+                {0,0,0,0,0,0,0,1,1,0,0,0,0}
+        };
+
+        int res = solver.maxAreaIsland(grid);
+        System.out.println(res);
+        // 6
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] grid = {
+                {0,0,0,0,0,0,0,},
+        };
+
+        int res = solver.maxAreaIsland(grid);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/MinimumDepthBinaryTreeTest.java b/algorithm/src/test/java/BSF_DSF/MinimumDepthBinaryTreeTest.java
new file mode 100644
index 0000000..036a1cc
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/MinimumDepthBinaryTreeTest.java
@@ -0,0 +1,19 @@
+package BSF_DSF;
+
+import BFS_DFS.MinimumDepthBinaryTree;
+import binaryTree.TreeNode;
+import org.junit.Test;
+
+public class MinimumDepthBinaryTreeTest {
+
+    MinimumDepthBinaryTree solver = new MinimumDepthBinaryTree();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{3,9,20,-1,-1,15,7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        int res = solver.minimumDepthBinaryTree(root);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/NumberClosedIslandsTest.java b/algorithm/src/test/java/BSF_DSF/NumberClosedIslandsTest.java
new file mode 100644
index 0000000..6676b13
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/NumberClosedIslandsTest.java
@@ -0,0 +1,25 @@
+package BSF_DSF;
+
+import BFS_DFS.NumberClosedIslands;
+import BFS_DFS.NumberEnclaves;
+import org.junit.Test;
+
+public class NumberClosedIslandsTest {
+
+    NumberClosedIslands solver = new NumberClosedIslands();
+
+    @Test
+    public void testOne() {
+        int[][] grid = new int[][] {
+                {1,1,1,1,1,1,1,0},
+                {1,0,0,0,0,1,1,0},
+                {1,0,1,0,1,1,1,0},
+                {1,0,0,0,0,1,0,1},
+                {1,1,1,1,1,1,1,0}
+        };
+
+        int res = solver.numberClosedIslands(grid);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/NumberDistinctIslandsTest.java b/algorithm/src/test/java/BSF_DSF/NumberDistinctIslandsTest.java
new file mode 100644
index 0000000..b3eec3b
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/NumberDistinctIslandsTest.java
@@ -0,0 +1,38 @@
+package BSF_DSF;
+
+import BFS_DFS.NumberDistinctIslands;
+import BFS_DFS.NumberIslands;
+import org.junit.Test;
+
+public class NumberDistinctIslandsTest {
+
+    NumberDistinctIslands solver = new NumberDistinctIslands();
+
+    @Test
+    public void testOne() {
+        char[][] grid = {
+                {'1','1','0','0','0'},
+                {'1','1','0','0','0'},
+                {'0','0','0','1','1'},
+                {'0','0','0','1','1'},
+        };
+
+        int res = solver.numberDistinctIslands(grid);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testTwo() {
+        char[][] grid = {
+                {'1','1','0','1','1'},
+                {'1','0','0','0','0'},
+                {'0','0','0','0','1'},
+                {'1','1','0','1','1'},
+        };
+
+        int res = solver.numberDistinctIslands(grid);
+        System.out.println(res);
+        // 3
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/NumberEnclavesTest.java b/algorithm/src/test/java/BSF_DSF/NumberEnclavesTest.java
new file mode 100644
index 0000000..ae5e0bf
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/NumberEnclavesTest.java
@@ -0,0 +1,22 @@
+package BSF_DSF;
+
+import BFS_DFS.NumberEnclaves;
+import org.junit.Test;
+
+public class NumberEnclavesTest {
+
+    NumberEnclaves solver = new NumberEnclaves();
+
+    @Test
+    public void testOne() {
+        int[][] grid = new int[][] {
+                {0,0,0,0},
+                {1,0,1,0},
+                {0,1,1,0},
+                {0,0,0,0}
+        };
+        int res = solver.numberEnclaves(grid);
+        System.out.println(res);
+        // 3
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/NumberIslandsTest.java b/algorithm/src/test/java/BSF_DSF/NumberIslandsTest.java
new file mode 100644
index 0000000..f7cf839
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/NumberIslandsTest.java
@@ -0,0 +1,37 @@
+package BSF_DSF;
+
+import BFS_DFS.NumberIslands;
+import org.junit.Test;
+
+public class NumberIslandsTest {
+    NumberIslands solver = new NumberIslands();
+
+    @Test
+    public void testOne() {
+        char[][] grid = {
+             {'1','1','1','1','0'},
+            {'1','1','0','1','0'},
+            {'1','1','0','0','0'},
+            {'0','0','0','0','0'}
+        };
+
+        int res = solver.numberIslands(grid);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testTwo() {
+        char[][] grid = {
+                {'1','1','0','0','0'},
+                {'1','1','0','0','0'},
+                {'0','0','1','0','0'},
+                {'0','0','0','1','1'}
+        };
+
+        int res = solver.numberIslands(grid);
+        System.out.println(res);
+        // 3
+
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/OpenTheLockTest.java b/algorithm/src/test/java/BSF_DSF/OpenTheLockTest.java
new file mode 100644
index 0000000..9ed969f
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/OpenTheLockTest.java
@@ -0,0 +1,50 @@
+package BSF_DSF;
+
+import BFS_DFS.OpenTheLock;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class OpenTheLockTest {
+
+    OpenTheLock solver = new OpenTheLock();
+
+    @Test
+    public void testOne() {
+        ArrayList<String> depends = new ArrayList<>();
+        depends.add("0201");
+        depends.add("0101");
+        depends.add("0102");
+        depends.add("1212");
+        depends.add("2002");
+        String target = "0202";
+
+        int res = solver.openTheLock(depends, target);
+        System.out.println(res);
+        /**
+         * 6
+         */
+
+    }
+
+    @Test
+    public void testTwo() {
+        ArrayList<String> depends = new ArrayList<>();
+        depends.add("8887");
+        depends.add("8889");
+        depends.add("8878");
+        depends.add("8898");
+        depends.add("8788");
+        depends.add("8988");
+        depends.add("7888");
+        depends.add("9888");
+        String target = "8888";
+
+        int res = solver.openTheLock(depends, target);
+        System.out.println(res);
+        /**
+         *  -1
+         */
+
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/SlidingPuzzleTest.java b/algorithm/src/test/java/BSF_DSF/SlidingPuzzleTest.java
new file mode 100644
index 0000000..59ad129
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/SlidingPuzzleTest.java
@@ -0,0 +1,41 @@
+package BSF_DSF;
+
+import BFS_DFS.SlidingPuzzle;
+import org.junit.Test;
+
+public class SlidingPuzzleTest {
+    SlidingPuzzle slover = new SlidingPuzzle();
+
+    @Test
+    public void testOne() {
+        int[][] nums = new int[][] {
+                {1,2,3},
+                {4,0,5}
+        };
+        int res = slover.slidingPuzzle(nums);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] nums = new int[][] {
+                {1,2,3},
+                {5,4,0}
+        };
+        int res = slover.slidingPuzzle(nums);
+        System.out.println(res);
+        // -1
+    }
+
+    @Test
+    public void testThree() {
+        int[][] nums = new int[][] {
+                {4,1,2},
+                {5,0,3}
+        };
+        int res = slover.slidingPuzzle(nums);
+        System.out.println(res);
+        // 5
+    }
+}
diff --git a/algorithm/src/test/java/BSF_DSF/SurroundedRegionsTest.java b/algorithm/src/test/java/BSF_DSF/SurroundedRegionsTest.java
new file mode 100644
index 0000000..78542bd
--- /dev/null
+++ b/algorithm/src/test/java/BSF_DSF/SurroundedRegionsTest.java
@@ -0,0 +1,31 @@
+package BSF_DSF;
+
+import BFS_DFS.SurroundedRegions;
+import org.junit.Test;
+
+public class SurroundedRegionsTest {
+
+    SurroundedRegions solver = new SurroundedRegions();
+
+    @Test
+    public void testOne() {
+        char[][] board = new char[][]{
+                {'X','X','X','X'},
+                {'X','O','O','X'},
+                {'X','X','O','X'},
+                {'X','O','X','X'}
+        };
+
+        solver.surroundedRegions(board);
+        for(char[] t: board){
+            System.out.println(t);
+            /**
+             * XXXX
+             * XXXX
+             * XXXX
+             * XOXX
+             */
+        }
+
+    }
+}
diff --git a/algorithm/src/test/java/DP/BloodSimilarityTest.java b/algorithm/src/test/java/DP/BloodSimilarityTest.java
new file mode 100644
index 0000000..a466583
--- /dev/null
+++ b/algorithm/src/test/java/DP/BloodSimilarityTest.java
@@ -0,0 +1,15 @@
+package DP;
+
+import org.junit.Test;
+
+public class BloodSimilarityTest {
+    BloodSimilarity solver = new BloodSimilarity();
+
+    @Test
+    public void testOne() {
+        String str1 = "ACT";
+        String str2 = "AGCT";
+        int res = solver.bloodSimilarity(str1, str2);
+        System.out.println(res);
+    }
+}
diff --git a/algorithm/src/test/java/DP/DisjointLinesTest.java b/algorithm/src/test/java/DP/DisjointLinesTest.java
new file mode 100644
index 0000000..d36f94b
--- /dev/null
+++ b/algorithm/src/test/java/DP/DisjointLinesTest.java
@@ -0,0 +1,35 @@
+package DP;
+
+import org.junit.Test;
+
+public class DisjointLinesTest {
+
+    DisjointLines solver = new DisjointLines();
+
+    @Test
+    public void testOne() {
+        int[] nums1 = new int[]{1,4,2};
+        int[] nums2 = new int[]{1,2,4};
+        int res = solver.maxUncrossedLines(nums1, nums2);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums1 = new int[]{2,5,1,2,5};
+        int[] nums2 = new int[]{10,5,2,1,5,2};
+        int res = solver.maxUncrossedLines(nums1, nums2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testThree() {
+        int[] nums1 = new int[]{1,3,7,1,7,5};
+        int[] nums2 = new int[]{1,9,2,5,1};
+        int res = solver.maxUncrossedLines(nums1, nums2);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/algorithm/src/test/java/DP/EnvelopsTest.java b/algorithm/src/test/java/DP/EnvelopsTest.java
new file mode 100644
index 0000000..0615400
--- /dev/null
+++ b/algorithm/src/test/java/DP/EnvelopsTest.java
@@ -0,0 +1,4 @@
+package DP;
+
+public class EnvelopsTest {
+}
diff --git a/algorithm/src/test/java/DP/IsSubsequenceTest.java b/algorithm/src/test/java/DP/IsSubsequenceTest.java
new file mode 100644
index 0000000..bd8bd88
--- /dev/null
+++ b/algorithm/src/test/java/DP/IsSubsequenceTest.java
@@ -0,0 +1,25 @@
+package DP;
+
+import org.junit.Test;
+
+public class IsSubsequenceTest {
+    IsSubsequence solver = new IsSubsequence();
+
+    @Test
+    public void testOne(){
+        String s = "abc";
+        String t = "ahbgdc";
+        boolean res = solver.isSubsequence(s, t);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void testTwo(){
+        String s = "axc";
+        String t = "ahbgdc";
+        boolean res = solver.isSubsequence(s, t);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/algorithm/src/test/java/DP/LongestCommonSubsequenceIITest.java b/algorithm/src/test/java/DP/LongestCommonSubsequenceIITest.java
new file mode 100644
index 0000000..7894735
--- /dev/null
+++ b/algorithm/src/test/java/DP/LongestCommonSubsequenceIITest.java
@@ -0,0 +1,35 @@
+package DP;
+
+import org.junit.Test;
+
+public class LongestCommonSubsequenceIITest {
+
+    LongestCommonSubsequenceII solver = new LongestCommonSubsequenceII();
+
+    @Test
+    public void testOne(){
+        String text1 = "abcde";
+        String text2 = "ace";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testTwo(){
+        String text1 = "abc";
+        String text2 = "abc";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testThree(){
+        String text1 = "abc";
+        String text2 = "def";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/algorithm/src/test/java/DP/LongestCommonSubsequenceTest.java b/algorithm/src/test/java/DP/LongestCommonSubsequenceTest.java
new file mode 100644
index 0000000..b6db982
--- /dev/null
+++ b/algorithm/src/test/java/DP/LongestCommonSubsequenceTest.java
@@ -0,0 +1,35 @@
+package DP;
+
+import org.junit.Test;
+
+public class LongestCommonSubsequenceTest {
+
+    LongestCommonSubsequence solver = new LongestCommonSubsequence();
+
+    @Test
+    public void testOne(){
+        String text1 = "abcde";
+        String text2 = "ace";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testTwo(){
+        String text1 = "abc";
+        String text2 = "abc";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testThree(){
+        String text1 = "abc";
+        String text2 = "def";
+        int res = solver.longestCommonSubsequence(text1, text2);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/algorithm/src/test/java/DP/MinFallingPathSum2Test.java b/algorithm/src/test/java/DP/MinFallingPathSum2Test.java
new file mode 100644
index 0000000..f068b27
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinFallingPathSum2Test.java
@@ -0,0 +1,42 @@
+package DP;
+
+import org.junit.Test;
+
+public class MinFallingPathSum2Test {
+    MinFallingPathSum2 solver = new MinFallingPathSum2();
+
+    @Test
+    public void testOne() {
+        int[][] grid = {
+                {1,2,3},
+                {4,5,6},
+                {7,8,9}
+        };
+        int res = solver.minFallingPathSum(grid);
+        System.out.println(res);
+        // 13
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] grid = {{7}};
+        int res = solver.minFallingPathSum(grid);
+        System.out.println(res);
+        // 7
+    }
+
+    @Test
+    public void testThree() {
+        int[][] grid = {
+                {-73,61,43,-48,-36},
+                {3,30,27,57,10},
+                {96,-76,84,59,-15},
+                {5,-49,76,31,-7},
+                {97,91,61,-46,67}
+        };
+        int res = solver.minFallingPathSum(grid);
+        System.out.println(res);
+        // -192
+
+    }
+}
diff --git a/algorithm/src/test/java/DP/MinFallingPathSumIITest.java b/algorithm/src/test/java/DP/MinFallingPathSumIITest.java
new file mode 100644
index 0000000..6d42bfe
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinFallingPathSumIITest.java
@@ -0,0 +1,39 @@
+package DP;
+
+import org.junit.Test;
+
+public class MinFallingPathSumIITest {
+    MinFallingPathSumII solver = new MinFallingPathSumII();
+
+    @Test
+    public void testOne() {
+        int[][] matrix = {{2,1,3},{6,5,4},{7,8,9}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // 13
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] matrix = {{-19,57},{-40,-5}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -59
+    }
+
+    @Test
+    public void testThree() {
+        int[][] matrix = {{-48}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -48
+    }
+
+    @Test
+    public void testFour() {
+        int[][] matrix = {{100,-42,-46,-41},{31,97,10,-10},{-58,-51,82,89},{51,81,69,-51}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -48
+    }
+}
diff --git a/algorithm/src/test/java/DP/MinFallingPathSumTest.java b/algorithm/src/test/java/DP/MinFallingPathSumTest.java
new file mode 100644
index 0000000..5ded69c
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinFallingPathSumTest.java
@@ -0,0 +1,41 @@
+package DP;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class MinFallingPathSumTest {
+    MinFallingPathSum solver = new MinFallingPathSum();
+
+    @Test
+    public void testOne() {
+        int[][] matrix = {{2,1,3},{6,5,4},{7,8,9}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // 13
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] matrix = {{-19,57},{-40,-5}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -59
+    }
+
+    @Test
+    public void testThree() {
+        int[][] matrix = {{-48}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -48
+    }
+
+    @Test
+    public void testFour() {
+        int[][] matrix = {{100,-42,-46,-41},{31,97,10,-10},{-58,-51,82,89},{51,81,69,-51}};
+        int res = solver.minFallingPathSum(matrix);
+        System.out.println(res);
+        // -48
+    }
+}
diff --git a/algorithm/src/test/java/DP/MinPathSumTest.java b/algorithm/src/test/java/DP/MinPathSumTest.java
new file mode 100644
index 0000000..583728c
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinPathSumTest.java
@@ -0,0 +1,35 @@
+package DP;
+
+import org.junit.Test;
+
+public class MinPathSumTest {
+
+    MinPathSum solver = new MinPathSum();
+
+    @Test
+    public void testOne(){
+        int[][] grid = new int[][]{
+                {1,3,1},
+                {1,5,1},
+                {4,2,1}
+        };
+
+        int res = solver.minPathSum(grid);
+        System.out.println(res);
+        // 7
+    }
+
+    @Test
+    public void testTwo(){
+        int[][] grid = new int[][]{
+                {1,2,3},
+                {4,5,6}
+        };
+
+        int res = solver.minPathSum(grid);
+        System.out.println(res);
+        // 12
+    }
+
+
+}
diff --git a/algorithm/src/test/java/DP/MinimumTriangleTotalIITest.java b/algorithm/src/test/java/DP/MinimumTriangleTotalIITest.java
new file mode 100644
index 0000000..136873b
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinimumTriangleTotalIITest.java
@@ -0,0 +1,50 @@
+package DP;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MinimumTriangleTotalIITest {
+    MinimumTriangleTotalII solver = new MinimumTriangleTotalII();
+
+//    @Test
+    public void test() {
+        int res = Integer.MIN_VALUE;
+        System.out.println(res+1);
+        // -2147483647
+    }
+
+    @Test
+    public void testOne(){
+        int[][] nums = {{2},{3,4},{6,5,7},{4,1,8,3}};
+        List<List<Integer>> triangle = new ArrayList<>();
+        for(int i=0; i<nums.length; i++) {
+            List<Integer> list = new ArrayList<>();
+            for(int j=0; j<nums[i].length; j++) {
+                list.add(nums[i][j]);
+            }
+            triangle.add(list);
+        }
+        int res = solver.minimumTotal(triangle);
+        System.out.println(res);
+        // 11
+    }
+
+    @Test
+    public void testTwo(){
+        int[][] nums = {{-10}};
+        List<List<Integer>> triangle = new ArrayList<>();
+        for(int i=0; i<nums.length; i++) {
+            List<Integer> list = new ArrayList<>();
+            for(int j=0; j<nums[i].length; j++) {
+                list.add(nums[i][j]);
+            }
+            triangle.add(list);
+        }
+        int res = solver.minimumTotal(triangle);
+        System.out.println(res);
+        // -10
+    }
+
+}
diff --git a/algorithm/src/test/java/DP/MinimumTriangleTotalTest.java b/algorithm/src/test/java/DP/MinimumTriangleTotalTest.java
new file mode 100644
index 0000000..b7bcd25
--- /dev/null
+++ b/algorithm/src/test/java/DP/MinimumTriangleTotalTest.java
@@ -0,0 +1,52 @@
+package DP;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class MinimumTriangleTotalTest {
+    MinimumTriangleTotal solver = new MinimumTriangleTotal();
+
+//    @Test
+    public void test() {
+        int res = Integer.MIN_VALUE;
+        System.out.println(res+1);
+        // -2147483647
+    }
+
+    @Test
+    public void testOne(){
+        int[][] nums = {{2},{3,4},{6,5,7},{4,1,8,3}};
+        List<List<Integer>> triangle = new ArrayList<>();
+        for(int i=0; i<nums.length; i++) {
+            List<Integer> list = new ArrayList<>();
+            for(int j=0; j<nums[i].length; j++) {
+                list.add(nums[i][j]);
+            }
+            triangle.add(list);
+        }
+        int res = solver.minimumTotal(triangle);
+        System.out.println(res);
+        // 11
+    }
+
+    @Test
+    public void testTwo(){
+        int[][] nums = {{-10}};
+        List<List<Integer>> triangle = new ArrayList<>();
+        for(int i=0; i<nums.length; i++) {
+            List<Integer> list = new ArrayList<>();
+            for(int j=0; j<nums[i].length; j++) {
+                list.add(nums[i][j]);
+            }
+            triangle.add(list);
+        }
+        int res = solver.minimumTotal(triangle);
+        System.out.println(res);
+        // -10
+    }
+
+}
diff --git a/algorithm/src/test/java/DP/PalindromeListTest.java b/algorithm/src/test/java/DP/PalindromeListTest.java
new file mode 100644
index 0000000..bff4637
--- /dev/null
+++ b/algorithm/src/test/java/DP/PalindromeListTest.java
@@ -0,0 +1,59 @@
+package DP;
+
+
+import linkedList.doublePointer.ListNode;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PalindromeListTest {
+
+    private PalindromeList p = new PalindromeList();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {1,2,2,1};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[] {1,2,3,2,1};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = new int[] {1,1};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test4() {
+        int[] nums = new int[] {1, 2};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void test5() {
+        int[] nums = new int[] {1};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test6() {
+        int[] nums = new int[] {};
+        ListNode l = ListNode.numsToListNode(nums);
+        boolean res = p.palindrome(l);
+        Assert.assertTrue(res);
+    }
+}
diff --git a/algorithm/src/test/java/DP/ReverseNode2Test.java b/algorithm/src/test/java/DP/ReverseNode2Test.java
new file mode 100644
index 0000000..4a45702
--- /dev/null
+++ b/algorithm/src/test/java/DP/ReverseNode2Test.java
@@ -0,0 +1,37 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReverseNode2Test {
+
+    ReverseNode2 reverse = new ReverseNode2();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseNode(list, 0);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,3,4,5,6}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseNode(list, 5);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{5,4,3,2,1,6}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseNode(list, 7);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{6,5,4,3,2,1}, res);
+    }
+}
diff --git a/algorithm/src/test/java/DP/ReverseNode3Test.java b/algorithm/src/test/java/DP/ReverseNode3Test.java
new file mode 100644
index 0000000..900abe4
--- /dev/null
+++ b/algorithm/src/test/java/DP/ReverseNode3Test.java
@@ -0,0 +1,39 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReverseNode3Test {
+
+    ReverseNode3 reverse = new ReverseNode3();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseBetween(list, 0, 0);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,3,4,5,6}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseBetween(list, 2, 4);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,4,3,5,6}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseBetween(list, 2, 7);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,6,5,4,3}, res);
+    }
+
+
+}
diff --git a/algorithm/src/test/java/DP/ReverseNodeKGroupTest.java b/algorithm/src/test/java/DP/ReverseNodeKGroupTest.java
new file mode 100644
index 0000000..dbc670f
--- /dev/null
+++ b/algorithm/src/test/java/DP/ReverseNodeKGroupTest.java
@@ -0,0 +1,28 @@
+package DP;
+
+import linkedList.doublePointer.ListNode;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReverseNodeKGroupTest {
+
+    ReverseNodeKGroup reverse = new ReverseNodeKGroup();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseNodeKGroup(list, 2);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{2,1,4,3,6,5}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[]{1,2,3,4,5,6};
+        ListNode list = ListNode.numsToListNode(nums);
+        ListNode resList = reverse.reverseNodeKGroup(list,4);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{4,3,2,1,5,6}, res);
+    }
+}
diff --git a/algorithm/src/test/java/DP/ReverseNodeTest.java b/algorithm/src/test/java/DP/ReverseNodeTest.java
new file mode 100644
index 0000000..f43bb23
--- /dev/null
+++ b/algorithm/src/test/java/DP/ReverseNodeTest.java
@@ -0,0 +1,32 @@
+package DP;
+
+/**
+ * 206. 反转链表
+ */
+
+import linkedList.doublePointer.ListNode;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ReverseNodeTest {
+
+    private ReverseNode list = new ReverseNode();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {1,2,3,4,5};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resList = list.reverseNode(l);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{5,4,3,2,1}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[] {};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resList = list.reverseNode(l);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{}, res);
+    }
+}
diff --git a/algorithm/src/test/java/DP/RussianDollEnvelopesTest.java b/algorithm/src/test/java/DP/RussianDollEnvelopesTest.java
new file mode 100644
index 0000000..4973baa
--- /dev/null
+++ b/algorithm/src/test/java/DP/RussianDollEnvelopesTest.java
@@ -0,0 +1,4 @@
+package DP;
+
+public class RussianDollEnvelopesTest {
+}
diff --git a/algorithm/src/test/java/DP/UniquePathsWithObstaclesTest.java b/algorithm/src/test/java/DP/UniquePathsWithObstaclesTest.java
new file mode 100644
index 0000000..16bcdd3
--- /dev/null
+++ b/algorithm/src/test/java/DP/UniquePathsWithObstaclesTest.java
@@ -0,0 +1,40 @@
+package DP;
+
+import org.junit.Test;
+
+public class UniquePathsWithObstaclesTest {
+    UniquePathsWithObstacles solver = new UniquePathsWithObstacles();
+
+    @Test
+    public void testOne(){
+        int[][] obstacleGrid = new int[][]{
+                {0,0,0},
+                {0,1,0},
+                {0,0,0}
+        };
+        int res = solver.uniquePathsWithObstacles(obstacleGrid);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testTwo(){
+        int[][] obstacleGrid = new int[][]{
+                {0,1},
+                {0,0},
+        };
+        int res = solver.uniquePathsWithObstacles(obstacleGrid);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testThree(){
+        int[][] obstacleGrid = new int[][]{
+                {1,0},
+        };
+        int res = solver.uniquePathsWithObstacles(obstacleGrid);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/algorithm/src/test/java/JavaStudy.java b/algorithm/src/test/java/JavaStudy.java
new file mode 100644
index 0000000..e0bd87f
--- /dev/null
+++ b/algorithm/src/test/java/JavaStudy.java
@@ -0,0 +1,10 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class JavaStudy {
+
+    public static void main(String[] args) {
+
+
+    }
+}
diff --git a/algorithm/src/test/java/alibaba/DuplicateLengthTest.java b/algorithm/src/test/java/alibaba/DuplicateLengthTest.java
new file mode 100644
index 0000000..0bb89b5
--- /dev/null
+++ b/algorithm/src/test/java/alibaba/DuplicateLengthTest.java
@@ -0,0 +1,43 @@
+package alibaba;
+
+import org.junit.Test;
+
+public class DuplicateLengthTest {
+
+    DuplicateLength solver = new DuplicateLength();
+
+    @Test
+    public void testOne() {
+        String str = "aa";
+        int res = solver.duplicateLength(str);
+        System.out.println(res);
+        // 0
+    }
+
+    @Test
+    public void testTwo() {
+        String str = "abca";
+        int res = solver.duplicateLength(str);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testThree() {
+        String str = "cbzxy";
+        int res = solver.duplicateLength(str);
+        System.out.println(res);
+        // -1
+    }
+
+    @Test
+    public void testFour() {
+        String str = "cabbac";
+        int res = solver.duplicateLength(str);
+        System.out.println(res);
+        // 4
+    }
+
+
+
+}
diff --git a/algorithm/src/test/java/array/binarySearch/EatBananaTest.java b/algorithm/src/test/java/array/binarySearch/EatBananaTest.java
new file mode 100644
index 0000000..da43217
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/EatBananaTest.java
@@ -0,0 +1,33 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EatBananaTest {
+
+    private EatBanana eat = new EatBanana();
+
+    @Test
+    public void eatBanana1() {
+        int[] nums = new int[] {3,6,7,11};
+        int hour = 8;
+        int res = eat.eatBanana(nums, hour);
+        Assert.assertEquals(4, res);
+    }
+
+    @Test
+    public void eatBanana2() {
+        int[] nums = new int[] {30,11,23,4,20};
+        int hour = 5;
+        int res = eat.eatBanana(nums, hour);
+        Assert.assertEquals(30,res);
+    }
+
+    @Test
+    public void eatBanana3() {
+        int[] nums = new int[] {30,11,23,4,20};
+        int hour = 6;
+        int res = eat.eatBanana(nums, hour);
+        Assert.assertEquals(23, res);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/IsSubsequenceTest.java b/algorithm/src/test/java/array/binarySearch/IsSubsequenceTest.java
new file mode 100644
index 0000000..ada949f
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/IsSubsequenceTest.java
@@ -0,0 +1,26 @@
+package array.binarySearch;
+
+import org.junit.Test;
+
+public class IsSubsequenceTest {
+
+    IsSubsequence solver = new IsSubsequence();
+
+    @Test
+    public void testOne() {
+        String s = "abc";
+        String t = "ahbgdc";
+        boolean res = solver.isSubsequence(s, t);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void testTwo() {
+        String s = "axc";
+        String t = "ahbgdc";
+        boolean res = solver.isSubsequence(s, t);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/PeakArrayTest.java b/algorithm/src/test/java/array/binarySearch/PeakArrayTest.java
new file mode 100644
index 0000000..8b64ca6
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/PeakArrayTest.java
@@ -0,0 +1,30 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PeakArrayTest {
+
+    private PeakArray peak = new PeakArray();
+
+    @Test
+    public void peakArrayTest1() {
+        int[] nums = new int[] {};
+        int res = peak.peakArray(nums);
+        Assert.assertEquals(res, -1);
+    }
+
+    @Test
+    public void peakArrayTest2() {
+        int[] nums = new int[] {1,3,5,7,6};
+        int res = peak.peakArray(nums);
+        Assert.assertEquals(res, 3);
+    }
+
+    @Test
+    public void peakArrayTest3() {
+        int[] nums = new int[] {0,1,0};
+        int res = peak.peakArray(nums);
+        Assert.assertEquals(res, 1);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/PreimageSizeZFTest.java b/algorithm/src/test/java/array/binarySearch/PreimageSizeZFTest.java
new file mode 100644
index 0000000..5eae8d4
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/PreimageSizeZFTest.java
@@ -0,0 +1,39 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PreimageSizeZFTest {
+
+    private PreimageSizeZF size = new PreimageSizeZF();
+
+    @Test
+    public void preimageSizeZFTest1() {
+        int n = size.preimageSizeZF(0);
+        Assert.assertEquals(n, 5);
+    }
+
+    @Test
+    public void preimageSizeZFTest2() {
+        int n = size.preimageSizeZF(1);
+        Assert.assertEquals(n, 5);
+    }
+
+    @Test
+    public void preimageSizeZFTest3() {
+        int n = size.preimageSizeZF(2);
+        Assert.assertEquals(n, 5);
+    }
+
+    @Test
+    public void preimageSizeZFTest5() {
+        int n = size.preimageSizeZF(5);
+        Assert.assertEquals(n, 0);
+    }
+
+    @Test
+    public void preimageSizeZFTest6() {
+        int n = size.preimageSizeZF(6);
+        Assert.assertEquals(n, 5);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/SearchInsertPositionTest.java b/algorithm/src/test/java/array/binarySearch/SearchInsertPositionTest.java
new file mode 100644
index 0000000..78cd5d2
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/SearchInsertPositionTest.java
@@ -0,0 +1,49 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SearchInsertPositionTest {
+
+    @Test
+    public void searchInsertTest1() {
+        int[] nums = new int[] {};
+        int res = new SearchInsertPosition().searchInsert(nums, 5);
+        Assert.assertEquals(res, 0);
+    }
+
+
+    @Test
+    public void searchInsertTest2() {
+        int[] nums = new int[] {1,3,5,6};
+        int res = new SearchInsertPosition().searchInsert(nums, 5);
+        Assert.assertEquals(res, 2);
+    }
+
+    @Test
+    public void searchInsertTest3() {
+        int[] nums = new int[] {1,3,5,6};
+        int res = new SearchInsertPosition().searchInsert(nums, 2);
+        Assert.assertEquals(res, 1);
+    }
+
+    @Test
+    public void searchInsertTest4() {
+        int[] nums = new int[] {1,3,5,6};
+        int res = new SearchInsertPosition().searchInsert(nums, 8);
+        Assert.assertEquals(res, 4);
+    }
+
+    @Test
+    public void searchInsertTest5() {
+        int[] nums = new int[] {1,3,5,6};
+        int res = new SearchInsertPosition().searchInsert(nums, -1);
+        Assert.assertEquals(res, 0);
+    }
+
+
+
+
+
+
+}
diff --git a/algorithm/src/test/java/array/binarySearch/SearchMatrixTest.java b/algorithm/src/test/java/array/binarySearch/SearchMatrixTest.java
new file mode 100644
index 0000000..7f11828
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/SearchMatrixTest.java
@@ -0,0 +1,53 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * 74. 搜索⼆维矩阵
+ */
+
+public class SearchMatrixTest {
+
+//    @Test
+    public void searchMatrixTest1() {
+        int[][] nums = new int[][] {{}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 3);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void searchMatrixTest2() {
+        int[][] nums = new int[][] {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 3);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void searchMatrixTest3() {
+        int[][] nums = new int[][] {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 0);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void searchMatrixTest4() {
+        int[][] nums = new int[][] {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 60);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void searchMatrixTest5() {
+        int[][] nums = new int[][] {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 61);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void searchMatrixTest6() {
+        int[][] nums = new int[][] {{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        boolean res = new SearchMatrix().searchMatrix(nums, 11);
+        Assert.assertTrue(res);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/SearchPositionTest.java b/algorithm/src/test/java/array/binarySearch/SearchPositionTest.java
new file mode 100644
index 0000000..bb84f7c
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/SearchPositionTest.java
@@ -0,0 +1,30 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SearchPositionTest {
+
+    private SearchPosition search = new SearchPosition();
+
+    @Test
+    public void searchTest1() {
+        int[] nums = new int[] {-1,0,3,5,9,12};
+        int res = search.search(nums, 9);
+        Assert.assertEquals(4, res);
+    }
+
+    @Test
+    public void searchTest2() {
+        int[] nums = new int[] {-1,0,3,5,9,12};
+        int res = search.search(nums, 9);
+        Assert.assertEquals(4, res);
+    }
+
+    @Test
+    public void searchTest3() {
+        int[] nums = new int[] {};
+        int res = search.search(nums, 2);
+        Assert.assertEquals(-1, res);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/SearchRangeTest.java b/algorithm/src/test/java/array/binarySearch/SearchRangeTest.java
new file mode 100644
index 0000000..c145629
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/SearchRangeTest.java
@@ -0,0 +1,44 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SearchRangeTest {
+
+    @Test
+    public void searchRangeTest1() {
+        int[] nums = new int[] {};
+        int[] res = new SearchRange().searchRange(nums, 8);
+        Assert.assertArrayEquals(res, new int[]{-1,-1});
+    }
+
+
+
+    @Test
+    public void searchRangeTest2() {
+        int[] nums = new int[] {5,7,7,8,8,10};
+        int[] res = new SearchRange().searchRange(nums, 8);
+        Assert.assertArrayEquals(res, new int[]{3,4});
+
+    }
+
+    @Test
+    public void searchRangeTest3() {
+        int[] nums = new int[] {5,7,7,8,8,10};
+        int[] res = new SearchRange().searchRange(nums, 6);
+        Assert.assertArrayEquals(res, new int[]{-1,-1});
+
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+}
diff --git a/algorithm/src/test/java/array/binarySearch/ShipWithinDaysTest.java b/algorithm/src/test/java/array/binarySearch/ShipWithinDaysTest.java
new file mode 100644
index 0000000..3da52f6
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/ShipWithinDaysTest.java
@@ -0,0 +1,30 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ShipWithinDaysTest {
+
+    private ShipWithinDays days = new ShipWithinDays();
+
+    @Test
+    public void shipWithinDays1() {
+        int[] nums = new int[]{1,2,3,4,5,6,7,8,9,10};
+        int res = days.shipWithinDays(nums, 5);
+        Assert.assertEquals(res, 15);
+    }
+
+    @Test
+    public void shipWithinDays2() {
+        int[] nums = new int[]{3,2,2,4,1,4};
+        int res = days.shipWithinDays(nums, 3);
+        Assert.assertEquals(res, 6);
+    }
+
+    @Test
+    public void shipWithinDays3() {
+        int[] nums = new int[]{1,2,3,1,1};
+        int res = days.shipWithinDays(nums, 4);
+        Assert.assertEquals(res, 3);
+    }
+}
diff --git a/algorithm/src/test/java/array/binarySearch/TailingZerosTest.java b/algorithm/src/test/java/array/binarySearch/TailingZerosTest.java
new file mode 100644
index 0000000..6be02e8
--- /dev/null
+++ b/algorithm/src/test/java/array/binarySearch/TailingZerosTest.java
@@ -0,0 +1,27 @@
+package array.binarySearch;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TailingZerosTest {
+
+    private TailingZeros tailing = new TailingZeros();
+
+    @Test
+    public void tailingZerosTest1() {
+        int res = tailing.tailingZeros(3);
+        Assert.assertEquals(res, 0);
+    }
+
+    @Test
+    public void tailingZerosTest2() {
+        int res = tailing.tailingZeros(125);
+        Assert.assertEquals(res, 31);
+    }
+
+    @Test
+    public void tailingZerosTest3() {
+        int res = tailing.tailingZeros(25);
+        Assert.assertEquals(res, 6);
+    }
+}
diff --git a/algorithm/src/test/java/array/other/AdvantageShuffleTest.java b/algorithm/src/test/java/array/other/AdvantageShuffleTest.java
new file mode 100644
index 0000000..519e617
--- /dev/null
+++ b/algorithm/src/test/java/array/other/AdvantageShuffleTest.java
@@ -0,0 +1,28 @@
+package array.other;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class AdvantageShuffleTest {
+
+    AdvantageShuffle solver = new AdvantageShuffle();
+
+    @Test
+    public void testOne(){
+        int[] nums1 = {2,7,11,15};
+        int[] nums2 = {1,10,4,11};
+        int[] res = solver.advantageShuffle(nums1, nums2);
+        System.out.println(Arrays.toString(res));
+        // [2, 11, 7, 15]
+    }
+
+    @Test
+    public void testTwo(){
+        int[] nums1 = {12,24,8,32};
+        int[] nums2 = {13,25,32,11};
+        int[] res = solver.advantageShuffle(nums1, nums2);
+        System.out.println(Arrays.toString(res));
+        // [24, 32, 8, 12]
+    }
+}
diff --git a/algorithm/src/test/java/array/other/ContainerWithMostWaterTest.java b/algorithm/src/test/java/array/other/ContainerWithMostWaterTest.java
new file mode 100644
index 0000000..c88b55f
--- /dev/null
+++ b/algorithm/src/test/java/array/other/ContainerWithMostWaterTest.java
@@ -0,0 +1,16 @@
+package array.other;
+
+import org.junit.Test;
+
+public class ContainerWithMostWaterTest {
+
+    ContainerWithMostWater solver = new ContainerWithMostWater();
+
+    @Test
+    public void  testOne() {
+        int[] nums = new int[] {1,8,6,2,5,4,8,3,7};
+        int res = solver.containerWithMOstWater(nums);
+        System.out.println(res);
+        // 49
+    }
+}
diff --git a/algorithm/src/test/java/array/other/IntervalListIntersectionsTest.java b/algorithm/src/test/java/array/other/IntervalListIntersectionsTest.java
new file mode 100644
index 0000000..479319c
--- /dev/null
+++ b/algorithm/src/test/java/array/other/IntervalListIntersectionsTest.java
@@ -0,0 +1,29 @@
+package array.other;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class IntervalListIntersectionsTest {
+
+    IntervalListIntersections solver = new IntervalListIntersections();
+
+    @Test
+    public void testOne() {
+        int[][] firstList = {{0,2},{5,10},{13,23},{24,25}};
+        int[][] secondList = {{1,5}, {8,12},{15,24},{25,26}};
+        ArrayList<ArrayList<Integer>> res = solver.intervalListIntersections(firstList, secondList);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [1, 2]
+             * [5, 5]
+             * [8, 10]
+             * [15, 23]
+             * [24, 24]
+             * [25, 25]
+             */
+        }
+
+    }
+}
diff --git a/algorithm/src/test/java/array/other/MaxRepeatSubStringTest.java b/algorithm/src/test/java/array/other/MaxRepeatSubStringTest.java
new file mode 100644
index 0000000..03d0237
--- /dev/null
+++ b/algorithm/src/test/java/array/other/MaxRepeatSubStringTest.java
@@ -0,0 +1,15 @@
+package array.other;
+
+import org.junit.Test;
+
+public class MaxRepeatSubStringTest {
+    MaxRepeatSubString solver = new MaxRepeatSubString();
+
+    @Test
+    public void testOne() {
+        String sequence = "aaabaaaabaaabaaaabaaaabaaaabaaaaba";
+        String word = "aaaba";
+        int res = solver.maxRepeating(sequence, word);
+        System.out.println(res);
+    }
+}
diff --git a/algorithm/src/test/java/array/other/RemoveDuplicateSortedArrayTest.java b/algorithm/src/test/java/array/other/RemoveDuplicateSortedArrayTest.java
new file mode 100644
index 0000000..e829157
--- /dev/null
+++ b/algorithm/src/test/java/array/other/RemoveDuplicateSortedArrayTest.java
@@ -0,0 +1,18 @@
+package array.other;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class RemoveDuplicateSortedArrayTest {
+
+    RemoveDuplicateSortedArray solver = new RemoveDuplicateSortedArray();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{0,0,1,2,2,3,3,};
+        solver.removeDuplicateSortedArray(nums);
+        System.out.println(Arrays.toString(nums));
+        // [0, 1, 2, 3, 0, 0, 0]
+    }
+}
diff --git a/algorithm/src/test/java/array/other/Search2DMatrixIITest.java b/algorithm/src/test/java/array/other/Search2DMatrixIITest.java
new file mode 100644
index 0000000..81d83a9
--- /dev/null
+++ b/algorithm/src/test/java/array/other/Search2DMatrixIITest.java
@@ -0,0 +1,41 @@
+package array.other;
+
+import org.junit.Test;
+
+public class Search2DMatrixIITest {
+
+    Search2DMatrixII solver = new Search2DMatrixII();
+
+    @Test
+    public void testOne() {
+        int[][] nums = {
+                {1,4,7,11,15},
+                {2,5,8,12,19},
+                {3,6,9,16,22},
+                {10,13,14,17,24},
+                {18,21,23,26,30}
+        };
+        int target = 5;
+
+        boolean res = solver.search2DMatrixII(nums, target);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void testTwo() {
+        int[][] nums = {
+                {1,4,7,11,15},
+                {2,5,8,12,19},
+                {3,6,9,16,22},
+                {10,13,14,17,24},
+                {18,21,23,26,30}
+        };
+        int target = 20;
+
+        boolean res = solver.search2DMatrixII(nums, target);
+        System.out.println(res);
+        // false
+    }
+
+}
diff --git a/algorithm/src/test/java/array/other/SquaresSortedArrayTest.java b/algorithm/src/test/java/array/other/SquaresSortedArrayTest.java
new file mode 100644
index 0000000..401618b
--- /dev/null
+++ b/algorithm/src/test/java/array/other/SquaresSortedArrayTest.java
@@ -0,0 +1,18 @@
+package array.other;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class SquaresSortedArrayTest {
+
+    SquaresSortedArray solver = new SquaresSortedArray();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{-4, -1, 0, 3, 10};
+        int[] res = solver.squaresSortedArray(nums);
+        System.out.println(Arrays.toString(res));
+        // [0, 1, 9, 16, 100]
+    }
+}
diff --git a/algorithm/src/test/java/array/other/TrappingRainWaterTest.java b/algorithm/src/test/java/array/other/TrappingRainWaterTest.java
new file mode 100644
index 0000000..5ea8dd2
--- /dev/null
+++ b/algorithm/src/test/java/array/other/TrappingRainWaterTest.java
@@ -0,0 +1,24 @@
+package array.other;
+
+import org.junit.Test;
+
+public class TrappingRainWaterTest {
+
+    TrappingRainWater solver = new TrappingRainWater();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {0,1,0,2,1,0,1,3,2,1,2,1};
+        int res = solver.trappingRainWater(nums);
+        System.out.println(res);
+        // 6
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = new int[] {4,2,0,3,2,5};
+        int res = solver.trappingRainWater(nums);
+        System.out.println(res);
+        // 9
+    }
+}
diff --git a/algorithm/src/test/java/array/other/TwoSumLessThanKTest.java b/algorithm/src/test/java/array/other/TwoSumLessThanKTest.java
new file mode 100644
index 0000000..359bca3
--- /dev/null
+++ b/algorithm/src/test/java/array/other/TwoSumLessThanKTest.java
@@ -0,0 +1,26 @@
+package array.other;
+
+import org.junit.Test;
+
+public class TwoSumLessThanKTest {
+
+    TwoSumLessThanK solver = new TwoSumLessThanK();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {34,23,1,24,75,33,54,8};
+        int k = 60;
+        int res = solver.twoSumLessThanK(nums, k);
+        System.out.println(res);
+        // 58
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = new int[] {10,20,30};
+        int k = 15;
+        int res = solver.twoSumLessThanK(nums, k);
+        System.out.println(res);
+        // -1
+    }
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/FindAnagramsTest.java b/algorithm/src/test/java/array/slideWIndow/FindAnagramsTest.java
new file mode 100644
index 0000000..534da35
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/FindAnagramsTest.java
@@ -0,0 +1,43 @@
+package array.slideWIndow;
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.FindAnagrams;
+
+import java.util.List;
+
+public class FindAnagramsTest {
+
+    private FindAnagrams anagrams = new FindAnagrams();
+
+    @Test
+    public void findAnagrams1() {
+        String s = "cbaebabacd", p = "abc";
+        int[] expect = new int[] {0, 6};
+        List<Integer> resArray = anagrams.findAnagrams(s, p);
+        int[] res = new int[resArray.size()];
+
+        for(int i=0;i<resArray.size();i++) {
+            res[i] = resArray.get(i);
+        }
+        Assert.assertArrayEquals(expect, res);
+    }
+
+    @Test
+    public void findAnagrams2() {
+        String s = "abab", p = "ab";
+        int[] expect = new int[] {0, 1, 2};
+        List<Integer> resArray = anagrams.findAnagrams(s, p);
+        int[] res = new int[resArray.size()];
+
+        for(int i=0;i<resArray.size();i++) {
+            res[i] = resArray.get(i);
+        }
+        Assert.assertArrayEquals(expect, res);
+
+
+    }
+
+
+
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/LengthOfLongestSubstringTest.java b/algorithm/src/test/java/array/slideWIndow/LengthOfLongestSubstringTest.java
new file mode 100644
index 0000000..7525410
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/LengthOfLongestSubstringTest.java
@@ -0,0 +1,32 @@
+package array.slideWIndow;
+
+/**
+ * 3. 无重复字符的最长子串
+ */
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.LengthOfLongestSubstring;
+
+public class LengthOfLongestSubstringTest {
+
+    private LengthOfLongestSubstring len = new LengthOfLongestSubstring();
+
+    @Test
+    public void test1() {
+        String s = new String("abcabcbb");
+        Assert.assertEquals(3, len.lengthOfLongestSubstring(s));
+    }
+
+    @Test
+    public void test2() {
+        String s = new String("bbbbb");
+        Assert.assertEquals(1, len.lengthOfLongestSubstring(s));
+    }
+
+    @Test
+    public void test3() {
+        String s = new String("pwwkew");
+        Assert.assertEquals(3, len.lengthOfLongestSubstring(s));
+    }
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/MinWindowSubstringTest.java b/algorithm/src/test/java/array/slideWIndow/MinWindowSubstringTest.java
new file mode 100644
index 0000000..e5d14ee
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/MinWindowSubstringTest.java
@@ -0,0 +1,30 @@
+package array.slideWIndow;
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.MinWindowSubstring;
+
+public class MinWindowSubstringTest {
+    private MinWindowSubstring min = new MinWindowSubstring();
+
+    @Test
+    public void minWindowSubstringTest1() {
+        String s = "ADOBECODEBANC", t = "ABC";
+        String res = min.minWindowSubstring(s, t);
+        Assert.assertEquals("BANC", res);
+    }
+
+    @Test
+    public void minWindowSubstringTest2() {
+        String s = "a", t = "a";
+        String res = min.minWindowSubstring(s, t);
+        Assert.assertEquals("a", res);
+    }
+
+    @Test
+    public void minWindowSubstringTest3() {
+        String s = "a", t = "aa";
+        String res = min.minWindowSubstring(s, t);
+        Assert.assertEquals("", res);
+    }
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/MinimumWindowTest.java b/algorithm/src/test/java/array/slideWIndow/MinimumWindowTest.java
new file mode 100644
index 0000000..d85325b
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/MinimumWindowTest.java
@@ -0,0 +1,24 @@
+package array.slideWIndow;
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.MinimumWindow;
+
+public class MinimumWindowTest {
+
+    private MinimumWindow min = new MinimumWindow();
+
+    @Test
+    public void maximumWindowTest1() {
+        int[] nums = new int[] {1,3,-1,-3,5,3,6,7};
+        int[] res = min.minimumWindow(nums, 3);
+        Assert.assertArrayEquals(new int[]{-1,-3,-3,-3,3,3}, res);
+    }
+
+    @Test
+    public void maximumWindowTest2() {
+        int[] nums = new int[] {1,3,-1,-3,5,3,6,7};
+        int[] res = min.minimumWindow(nums, 2);
+        Assert.assertArrayEquals(new int[]{1,-1,-3,-3,3,3,6}, res);
+    }
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/PermutationTest.java b/algorithm/src/test/java/array/slideWIndow/PermutationTest.java
new file mode 100644
index 0000000..b30e29d
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/PermutationTest.java
@@ -0,0 +1,17 @@
+package array.slideWIndow;
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.Permutation;
+
+public class PermutationTest {
+
+    private Permutation mutation = new Permutation();
+
+    @Test
+    public void permutationTest1() {
+        String s1 = "ab", s2 = "eidbaooo";
+        boolean res = mutation.permutation(s1,s2);
+        Assert.assertTrue(res);
+    }
+}
diff --git a/algorithm/src/test/java/array/slideWIndow/SlidingWindowMaximumTest.java b/algorithm/src/test/java/array/slideWIndow/SlidingWindowMaximumTest.java
new file mode 100644
index 0000000..de83813
--- /dev/null
+++ b/algorithm/src/test/java/array/slideWIndow/SlidingWindowMaximumTest.java
@@ -0,0 +1,18 @@
+package array.slideWIndow;
+
+import org.junit.Assert;
+import org.junit.Test;
+import array.slideWindow.SlidingWindowMaximum;
+
+public class SlidingWindowMaximumTest {
+
+    private SlidingWindowMaximum max = new SlidingWindowMaximum();
+
+    @Test
+    public void maximumWindowTest1() {
+        int[] nums = new int[] {1,3,-1,-3,5,3,6,7};
+//        int[] res = max.maximumWindow(nums, 3);
+        int[] res = max.maximumWindow2(nums, 3);
+        Assert.assertArrayEquals(new int[]{3,3,5,5,6,7}, res);
+    }
+}
diff --git a/algorithm/src/test/java/backTrack/CombinationSumTest.java b/algorithm/src/test/java/backTrack/CombinationSumTest.java
new file mode 100644
index 0000000..b226342
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/CombinationSumTest.java
@@ -0,0 +1,45 @@
+package backTrack;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class CombinationSumTest {
+
+    CombinationSum solver = new CombinationSum();
+
+    @Test
+    public void testOne(){
+        int[] candidates = new int[]{2,3,6,7};
+        int target = 7;
+
+        ArrayList<ArrayList<Integer>> res = solver.combinationSum(candidates, target);
+
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+    /**
+     * [2, 2, 3]
+     * [7]
+     */
+
+
+    @Test
+    public void testTwo(){
+        int[] candidates = new int[]{2,3,5};
+        int target = 8;
+
+        ArrayList<ArrayList<Integer>> res = solver.combinationSum(candidates, target);
+
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+    /**
+     * [2, 2, 2, 2]
+     * [2, 3, 3]
+     * [3, 5]
+     */
+
+}
diff --git a/algorithm/src/test/java/backTrack/CombinationsTest.java b/algorithm/src/test/java/backTrack/CombinationsTest.java
new file mode 100644
index 0000000..602227c
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/CombinationsTest.java
@@ -0,0 +1,20 @@
+package backTrack;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class CombinationsTest {
+
+    Combinations solver = new Combinations();
+
+    @Test
+    public void testOne() {
+        int n = 4;
+        int k = 2;
+        ArrayList<ArrayList<Integer>> res = solver.combinations(n, k);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+}
diff --git a/algorithm/src/test/java/backTrack/GenerateParenthesesTest.java b/algorithm/src/test/java/backTrack/GenerateParenthesesTest.java
new file mode 100644
index 0000000..bf90ed4
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/GenerateParenthesesTest.java
@@ -0,0 +1,18 @@
+package backTrack;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class GenerateParenthesesTest {
+
+    GenerateParentheses pat = new GenerateParentheses();
+
+    @Test
+    public void testOne() {
+        ArrayList<String> res = pat.generateParentheses(3);
+        for (String s: res) {
+            System.out.println(s);
+        }
+    }
+}
diff --git a/algorithm/src/test/java/backTrack/MaximumDepthBinaryTreeTest.java b/algorithm/src/test/java/backTrack/MaximumDepthBinaryTreeTest.java
new file mode 100644
index 0000000..22e23f0
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/MaximumDepthBinaryTreeTest.java
@@ -0,0 +1,4 @@
+package backTrack;
+
+public class MaximumDepthBinaryTreeTest {
+}
diff --git a/algorithm/src/test/java/backTrack/NQueuesTest.java b/algorithm/src/test/java/backTrack/NQueuesTest.java
new file mode 100644
index 0000000..119924e
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/NQueuesTest.java
@@ -0,0 +1,32 @@
+package backTrack;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class NQueuesTest {
+
+    NQueues solver = new NQueues();
+
+    @Test
+    public void testOne() {
+        ArrayList<ArrayList<String>> res = solver.nQueues(4);
+        for(ArrayList<String> ls: res) {
+            for(String s: ls) {
+                System.out.println(s);
+            }
+            System.out.println();
+        }
+    }
+    /**
+     * .Q..
+     * ...Q
+     * Q...
+     * ..Q.
+     *
+     * ..Q.
+     * Q...
+     * ...Q
+     * .Q..
+     */
+}
diff --git a/algorithm/src/test/java/backTrack/PartitionKEqualSumSubsetsTest.java b/algorithm/src/test/java/backTrack/PartitionKEqualSumSubsetsTest.java
new file mode 100644
index 0000000..d971072
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/PartitionKEqualSumSubsetsTest.java
@@ -0,0 +1,26 @@
+package backTrack;
+
+import org.junit.Test;
+
+public class PartitionKEqualSumSubsetsTest {
+
+    PartitionKEqualSumSubsets solver = new PartitionKEqualSumSubsets();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {4,3,2,3,5,2,1};
+        int k = 4;
+        boolean res = solver.partitionKEqualSumSubsets(nums, k);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = new int[] {1,2,3,4};
+        int k = 3;
+        boolean res = solver.partitionKEqualSumSubsets(nums, k);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/algorithm/src/test/java/backTrack/PermutationsTest.java b/algorithm/src/test/java/backTrack/PermutationsTest.java
new file mode 100644
index 0000000..dfa5072
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/PermutationsTest.java
@@ -0,0 +1,28 @@
+package backTrack;
+
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class PermutationsTest {
+
+    Permutations solver = new Permutations();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{1,2,3};
+        ArrayList<ArrayList<Integer>> res = solver.permutations(nums);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+    /**
+     * [1, 2, 3]
+     * [1, 3, 2]
+     * [2, 1, 3]
+     * [2, 3, 1]
+     * [3, 1, 2]
+     * [3, 2, 1]
+     */
+}
diff --git a/algorithm/src/test/java/backTrack/SubsetsTest.java b/algorithm/src/test/java/backTrack/SubsetsTest.java
new file mode 100644
index 0000000..0b7c445
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/SubsetsTest.java
@@ -0,0 +1,29 @@
+package backTrack;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class SubsetsTest {
+
+    Subsets solver = new Subsets();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{1, 2, 3};
+        ArrayList<ArrayList<Integer>> res = solver.subsets(nums);
+        for(ArrayList<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+    /**
+     * []
+     * [1]
+     * [1, 2]
+     * [1, 2, 3]
+     * [1, 3]
+     * [2]
+     * [2, 3]
+     * [3]
+     */
+}
diff --git a/algorithm/src/test/java/backTrack/SudokuSolverTest.java b/algorithm/src/test/java/backTrack/SudokuSolverTest.java
new file mode 100644
index 0000000..65dd422
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/SudokuSolverTest.java
@@ -0,0 +1,47 @@
+package backTrack;
+
+import org.junit.Test;
+
+public class SudokuSolverTest {
+    SudokuSolver solver = new SudokuSolver();
+
+
+    @Test
+    public void testOne() {
+        char[][] board = new char[][]{
+                {'5','3','.','.','7','.','.','.','.'},
+                {'6','.','.','1','9','5','.','.','.'},
+                {'.','9','8','.','.','.','.','6','.'},
+                {'8','.','.','.','6','.','.','.','3'},
+                {'4','.','.','8','.','3','.','.','1'},
+                {'7','.','.','.','2','.','.','.','6'},
+                {'.','6','.','.','.','.','2','8','.'},
+                {'.','.','.','4','1','9','.','.','5'},
+                {'.','.','.','.','8','.','.','7','9'}
+        };
+
+        solver.sudokuSolver(board);
+        for(int i=0;i<board.length;i++) {
+            for(int j=0;j<board[0].length;j++) {
+                System.out.printf("%s\t", board[i][j]);
+            }
+            System.out.println();
+        }
+    }
+
+
+    /**
+     * 5	3	4	6	7	8	9	1	2
+     * 6	7	2	1	9	5	3	4	8
+     * 1	9	8	3	4	2	5	6	7
+     * 8	5	9	7	6	1	4	2	3
+     * 4	2	6	8	5	3	7	9	1
+     * 7	1	3	9	2	4	8	5	6
+     * 9	6	1	5	3	7	2	8	4
+     * 2	8	7	4	1	9	6	3	5
+     * 3	4	5	2	8	6	1	7	9
+     */
+
+
+}
+
diff --git a/algorithm/src/test/java/backTrack/TargetSum2Test.java b/algorithm/src/test/java/backTrack/TargetSum2Test.java
new file mode 100644
index 0000000..5be73cd
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/TargetSum2Test.java
@@ -0,0 +1,17 @@
+package backTrack;
+
+import org.junit.Test;
+
+public class TargetSum2Test {
+
+    TargetSum2 solver = new TargetSum2();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{1,1,1,1,1};
+
+        int res = solver.targetSum(nums, 3);
+        System.out.println(res);
+        // 5
+    }
+}
diff --git a/algorithm/src/test/java/backTrack/TargetSumTest.java b/algorithm/src/test/java/backTrack/TargetSumTest.java
new file mode 100644
index 0000000..0e89e62
--- /dev/null
+++ b/algorithm/src/test/java/backTrack/TargetSumTest.java
@@ -0,0 +1,17 @@
+package backTrack;
+
+import org.junit.Test;
+
+public class TargetSumTest {
+
+    TargetSum solver = new TargetSum();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[]{1,1,1,1,1};
+
+        int res = solver.targetSum(nums, 3);
+        System.out.println(res);
+        // 5
+    }
+}
diff --git a/algorithm/src/test/java/binaryHeap/KthLargestDataTest.java b/algorithm/src/test/java/binaryHeap/KthLargestDataTest.java
new file mode 100644
index 0000000..e01aad6
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/KthLargestDataTest.java
@@ -0,0 +1,39 @@
+package binaryHeap;
+
+/**
+ * 703. 数据流中的第 K 大元素
+ */
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashSet;
+
+public class KthLargestDataTest {
+
+    HashSet<Integer> set = new HashSet<>();
+
+    private KthLargestData kdata;
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {4, 5, 8, 2};
+        int k = 3;
+        kdata = new KthLargestData(k, nums);
+        int res;
+        res = kdata.add(3);
+        Assert.assertEquals(4, res);
+
+        res = kdata.add(5);
+        Assert.assertEquals(5, res);
+
+        res = kdata.add(10);
+        Assert.assertEquals(5, res);
+
+        res = kdata.add(9);
+        Assert.assertEquals(8, res);
+
+        res = kdata.add(4);
+        Assert.assertEquals(8, res);
+    }
+}
diff --git a/algorithm/src/test/java/binaryHeap/KthLargestElementTest.java b/algorithm/src/test/java/binaryHeap/KthLargestElementTest.java
new file mode 100644
index 0000000..d756abf
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/KthLargestElementTest.java
@@ -0,0 +1,23 @@
+package binaryHeap;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.omg.CORBA.INTERNAL;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class KthLargestElementTest {
+
+    private KthLargestElement large = new KthLargestElement();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {3,2,1,5,6,4};
+        int k=2;
+        int expect = 5;
+        int res = large.kthLargest(nums, k);
+        Assert.assertEquals(expect, res);
+    }
+
+}
diff --git a/algorithm/src/test/java/binaryHeap/LRUCacheTest.java b/algorithm/src/test/java/binaryHeap/LRUCacheTest.java
new file mode 100644
index 0000000..5a1e05d
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/LRUCacheTest.java
@@ -0,0 +1,4 @@
+package binaryHeap;
+
+public class LRUCacheTest {
+}
diff --git a/algorithm/src/test/java/binaryHeap/MaxFrequencyTest.java b/algorithm/src/test/java/binaryHeap/MaxFrequencyTest.java
new file mode 100644
index 0000000..bd9e70c
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/MaxFrequencyTest.java
@@ -0,0 +1,4 @@
+package binaryHeap;
+
+public class MaxFrequencyTest {
+}
diff --git a/algorithm/src/test/java/binaryHeap/MedianDataTest.java b/algorithm/src/test/java/binaryHeap/MedianDataTest.java
new file mode 100644
index 0000000..5747ee8
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/MedianDataTest.java
@@ -0,0 +1,26 @@
+package binaryHeap;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MedianDataTest {
+    private MedianData data = new MedianData();
+
+
+    @Test
+    public void test1() {
+
+        data.addNum(1);
+        data.addNum(2);
+        double res;
+        res = data.findMedian();
+        Assert.assertEquals(1.5, res, 0.00001);
+
+        data.addNum(3);
+        res = data.findMedian();
+        Assert.assertEquals(2.0, res, 0.00001);
+
+    }
+
+
+}
diff --git a/algorithm/src/test/java/binaryHeap/MergeSortedListsTest.java b/algorithm/src/test/java/binaryHeap/MergeSortedListsTest.java
new file mode 100644
index 0000000..639d31a
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/MergeSortedListsTest.java
@@ -0,0 +1,9 @@
+package binaryHeap;
+
+public class MergeSortedListsTest {
+
+
+
+
+
+}
diff --git a/algorithm/src/test/java/binaryHeap/MinStackTest.java b/algorithm/src/test/java/binaryHeap/MinStackTest.java
new file mode 100644
index 0000000..f874218
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/MinStackTest.java
@@ -0,0 +1,32 @@
+package binaryHeap;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MinStackTest {
+
+    private MinStack min = new MinStack();
+
+    @Test
+    public void test1() {
+        int res;
+        int expect;
+
+        min.push(-2);
+        min.push(0);
+        min.push(-3);
+
+        res = min.getMin();
+        expect = -3;
+        Assert.assertEquals(expect, res);
+
+        min.pop();
+        res = min.top();
+        expect = 0;
+        Assert.assertEquals(expect, res);
+
+        res = min.getMin();
+        expect = -2;
+        Assert.assertEquals(expect, res);
+    }
+}
diff --git a/algorithm/src/test/java/binaryHeap/SeatReserveTest.java b/algorithm/src/test/java/binaryHeap/SeatReserveTest.java
new file mode 100644
index 0000000..390a88f
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/SeatReserveTest.java
@@ -0,0 +1,42 @@
+package binaryHeap;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SeatReserveTest {
+
+    private SeatReserve seat;
+
+    @Test
+    public void test1() {
+        seat = new SeatReserve(5);
+        int res, expect;
+        res = seat.reserve();
+        expect = 1;
+        Assert.assertEquals(expect, res);
+
+        res = seat.reserve();
+        expect = 2;
+        Assert.assertEquals(expect, res);
+
+        seat.unreserve(2);
+
+        res = seat.reserve();
+        expect = 2;
+        Assert.assertEquals(expect, res);
+
+        res = seat.reserve();
+        expect = 3;
+        Assert.assertEquals(expect, res);
+
+        res = seat.reserve();
+        expect = 4;
+        Assert.assertEquals(expect, res);
+
+        res = seat.reserve();
+        expect = 5;
+        Assert.assertEquals(expect, res);
+
+        seat.unreserve(5);
+    }
+}
diff --git a/algorithm/src/test/java/binaryHeap/SingleThreadCPUTest.java b/algorithm/src/test/java/binaryHeap/SingleThreadCPUTest.java
new file mode 100644
index 0000000..b6ea1b5
--- /dev/null
+++ b/algorithm/src/test/java/binaryHeap/SingleThreadCPUTest.java
@@ -0,0 +1,31 @@
+package binaryHeap;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * 1834. 单线程 CPU
+ */
+
+public class SingleThreadCPUTest {
+
+    private SingleThreadCPU orders = new SingleThreadCPU();
+
+    @Test
+    public void test1() {
+        int[][] tasks = new int[][]{{1,2}, {2,4}, {3,2}, {4,1}};
+        int[] res = orders.singleThreadCPU(tasks);
+        int[] expect = new int[] {0,2,3,1};
+        Assert.assertArrayEquals(expect, res);
+    }
+
+    @Test
+    public void test2() {
+        int[][] tasks = new int[][]{{7,10}, {7,12}, {7,5}, {7,4}, {7,2}};
+        int[] res = orders.singleThreadCPU(tasks);
+        int[] expect = new int[] {4,3,2, 0, 1};
+        Assert.assertArrayEquals(expect, res);
+    }
+
+
+}
diff --git a/algorithm/src/test/java/binaryTree/BinaryTreeLevelOrderTraversalTest.java b/algorithm/src/test/java/binaryTree/BinaryTreeLevelOrderTraversalTest.java
new file mode 100644
index 0000000..cca2002
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/BinaryTreeLevelOrderTraversalTest.java
@@ -0,0 +1,25 @@
+package binaryTree;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class BinaryTreeLevelOrderTraversalTest {
+
+    BinaryTreeLevelOrderTraversal solver = new BinaryTreeLevelOrderTraversal();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {3, 9, 20, -1, -1, 15, 7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        ArrayList<ArrayList<Integer>> res = solver.binaryTreeLevelOrderTraversal(root);
+        for(ArrayList<Integer> t : res) {
+            System.out.println(t);
+            /**
+             * [3]
+             * [9, 20]
+             * [15, 7]
+             */
+        }
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/BinaryTreePostorderTraversalTest.java b/algorithm/src/test/java/binaryTree/BinaryTreePostorderTraversalTest.java
new file mode 100644
index 0000000..ffbc715
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/BinaryTreePostorderTraversalTest.java
@@ -0,0 +1,4 @@
+package binaryTree;
+
+public class BinaryTreePostorderTraversalTest {
+}
diff --git a/algorithm/src/test/java/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.java b/algorithm/src/test/java/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.java
new file mode 100644
index 0000000..d0a1c99
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.java
@@ -0,0 +1,25 @@
+package binaryTree;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+public class BinaryTreeZigzagLevelOrderTraversalTest {
+
+    BinaryTreeZigzagLevelOrderTraversal solver = new BinaryTreeZigzagLevelOrderTraversal();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {3, 9, 20, -1, -1, 15, 7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        LinkedList<LinkedList<Integer>> res = solver.zigzagOrder(root);
+        for(LinkedList<Integer> t: res) {
+            System.out.println(t);
+        }
+        /**
+         * [3]
+         * [20, 9]
+         * [15, 7]
+         */
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/DiameterBinaryTreeTest.java b/algorithm/src/test/java/binaryTree/DiameterBinaryTreeTest.java
new file mode 100644
index 0000000..f0befa4
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/DiameterBinaryTreeTest.java
@@ -0,0 +1,17 @@
+package binaryTree;
+
+import org.junit.Test;
+
+public class DiameterBinaryTreeTest {
+
+    DiameterBinaryTree solver = new DiameterBinaryTree();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {1,2,3,4,5,-1,-1};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        int res = solver.diameterBinaryTree(root);
+        System.out.println(res);
+        // 3
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/FlattenBinaryTreeToLinkedListTest.java b/algorithm/src/test/java/binaryTree/FlattenBinaryTreeToLinkedListTest.java
new file mode 100644
index 0000000..b87adbb
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/FlattenBinaryTreeToLinkedListTest.java
@@ -0,0 +1,21 @@
+package binaryTree;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+public class FlattenBinaryTreeToLinkedListTest {
+
+    FlattenBinaryTreeToLinkedList solver = new FlattenBinaryTreeToLinkedList();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {1,2,5,3,4,-1,6};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        LinkedList<TreeNode> res = solver.flattenBinaryTreeToLinkedList(root);
+        for(TreeNode t: res) {
+            System.out.print(t.val+" ");
+        }
+        // 1 2 3 4 5 6
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/InorderTraversalTest.java b/algorithm/src/test/java/binaryTree/InorderTraversalTest.java
new file mode 100644
index 0000000..695808c
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/InorderTraversalTest.java
@@ -0,0 +1,14 @@
+package binaryTree;
+
+import org.junit.Test;
+
+public class InorderTraversalTest {
+
+    private InorderTraversal inorder = new InorderTraversal();
+
+    @Test
+    public void test() {
+
+    }
+
+}
diff --git a/algorithm/src/test/java/binaryTree/IntegerTest.java b/algorithm/src/test/java/binaryTree/IntegerTest.java
new file mode 100644
index 0000000..df226ec
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/IntegerTest.java
@@ -0,0 +1,18 @@
+package binaryTree;
+
+import org.junit.Test;
+
+public class IntegerTest {
+
+    void change(Integer i) {
+        i = 21;
+    }
+
+    @Test
+    public void testOne() {
+        Integer i = 10;
+        change(i);
+        System.out.println(i);
+        // 10, i并没有改变
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/InvertBinaryTreeTest.java b/algorithm/src/test/java/binaryTree/InvertBinaryTreeTest.java
new file mode 100644
index 0000000..b4bf4ed
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/InvertBinaryTreeTest.java
@@ -0,0 +1,21 @@
+package binaryTree;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+
+public class InvertBinaryTreeTest {
+
+    InvertBinaryTree solver = new InvertBinaryTree();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {4,2,7,1,3,6,9};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        solver.invertBinaryTree(root);
+        LinkedList<Integer> res = TreeNode.treeNodeToNum(root);
+        System.out.println(res);
+        // [4, 7, 9, 6, 2, 3, 1]
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/MaximumDepthNTreeTest.java b/algorithm/src/test/java/binaryTree/MaximumDepthNTreeTest.java
new file mode 100644
index 0000000..4204183
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/MaximumDepthNTreeTest.java
@@ -0,0 +1,4 @@
+package binaryTree;
+
+public class MaximumDepthNTreeTest {
+}
diff --git a/algorithm/src/test/java/binaryTree/MinimumDepthBinaryTreeTest.java b/algorithm/src/test/java/binaryTree/MinimumDepthBinaryTreeTest.java
new file mode 100644
index 0000000..713b194
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/MinimumDepthBinaryTreeTest.java
@@ -0,0 +1,17 @@
+package binaryTree;
+
+import org.junit.Test;
+
+public class MinimumDepthBinaryTreeTest {
+
+    MinimumDepthBinaryTree solver = new MinimumDepthBinaryTree();
+
+    @Test
+    public void testOne() {
+        int[] nums = new int[] {3,9,20,-1,-1,15,7};
+        TreeNode root = TreeNode.numsToTreeNode(nums);
+        int res = solver.minimumDepthBinaryTree(root);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/SameTree2Test.java b/algorithm/src/test/java/binaryTree/SameTree2Test.java
new file mode 100644
index 0000000..5e15dbd
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/SameTree2Test.java
@@ -0,0 +1,19 @@
+package binaryTree;
+
+import org.junit.Test;
+
+public class SameTree2Test {
+
+    SameTree2 solver = new SameTree2();
+
+    @Test
+    public void testOne() {
+        int[] nums1 = new int[] {1,2,3};
+        int[] nums2 = new int[] {1,2,3};
+        TreeNode p = TreeNode.numsToTreeNode(nums1);
+        TreeNode q = TreeNode.numsToTreeNode(nums2);
+        boolean res = solver.sameTree(p, q);
+        System.out.println(res);
+        // true
+    }
+}
diff --git a/algorithm/src/test/java/binaryTree/SerializeAndDeserializeBinaryTreeTest.java b/algorithm/src/test/java/binaryTree/SerializeAndDeserializeBinaryTreeTest.java
new file mode 100644
index 0000000..b7a5eaa
--- /dev/null
+++ b/algorithm/src/test/java/binaryTree/SerializeAndDeserializeBinaryTreeTest.java
@@ -0,0 +1,22 @@
+package binaryTree;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+public class SerializeAndDeserializeBinaryTreeTest {
+    SerializeAndDeserializeBinaryTree solver = new SerializeAndDeserializeBinaryTree();
+
+    @Test
+    public void testOne() {
+        String root = "1,2,3,null,null,4,5";
+        TreeNode res = solver.deserialize(root);
+        LinkedList<Integer> nums = TreeNode.treeNodeToNum(res);
+        System.out.println(nums.toString());
+        // [1, 2, 3, 4, 5]
+
+        String str = solver.serialize(res);
+        System.out.println(str);
+        // 1,2,3,null,null,4,5,null,null,null,null
+    }
+}
diff --git a/algorithm/src/test/java/dataStructureDesign/FlattenNestedListIterator.java b/algorithm/src/test/java/dataStructureDesign/FlattenNestedListIterator.java
new file mode 100644
index 0000000..d40cf78
--- /dev/null
+++ b/algorithm/src/test/java/dataStructureDesign/FlattenNestedListIterator.java
@@ -0,0 +1,68 @@
+package dataStructureDesign;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ *  341 扁平化嵌套列表迭代器
+ */
+
+class NestedInteger {
+    Integer val;
+    LinkedList<NestedInteger> list;
+
+    public NestedInteger(int val) {
+        this.val = val;
+        this.list = null;
+    }
+
+    public NestedInteger(LinkedList<NestedInteger> list) {
+        this.val = null;
+        this.list = list;
+    }
+
+    // 判断是否存储的是一个整数
+    boolean isInteger() {
+        return val!=null;
+    }
+
+    // 是否是链表
+    boolean isList() {
+        return list!=null;
+    }
+
+    Integer getInteger() {
+        return val;
+    }
+
+    LinkedList<NestedInteger> getList() {
+        return list;
+    }
+}
+
+public class FlattenNestedListIterator implements Iterator<Integer> {
+
+    LinkedList<NestedInteger> list;
+
+    public FlattenNestedListIterator(LinkedList<NestedInteger> nestList) {
+        list = nestList;
+    }
+
+    @Override
+    public boolean hasNext() {
+        while(!list.isEmpty() && list.get(0).isList()) {
+            LinkedList<NestedInteger> temp = list.get(0).getList();
+            list.remove(0);
+            for(int i=temp.size()-1; i>=0; i--) {
+                list.addFirst(temp.get(0));
+            }
+        }
+        return list.size()>0;
+    }
+
+    @Override
+    public Integer next() {
+        return list.remove(0).getInteger();
+    }
+}
diff --git a/algorithm/src/test/java/dataStructureDesign/InsertDeleteGetRandomTest.java b/algorithm/src/test/java/dataStructureDesign/InsertDeleteGetRandomTest.java
new file mode 100644
index 0000000..621f21d
--- /dev/null
+++ b/algorithm/src/test/java/dataStructureDesign/InsertDeleteGetRandomTest.java
@@ -0,0 +1,19 @@
+package dataStructureDesign;
+
+import org.junit.Test;
+
+public class InsertDeleteGetRandomTest {
+
+    InsertDeleteGetRandom solver = new InsertDeleteGetRandom();
+
+    @Test
+    public void testOne() {
+        System.out.println(solver.insert(1)); // true
+        System.out.println(solver.remove(2)); // false
+        System.out.println(solver.insert(2)); // true
+        System.out.println(solver.getRandom()); // 2
+        System.out.println(solver.remove(1)); // true
+        System.out.println(solver.insert(2)); // false
+        System.out.println(solver.getRandom()); // 1
+    }
+}
diff --git a/algorithm/src/test/java/dataStructureDesign/LFUCacheTest.java b/algorithm/src/test/java/dataStructureDesign/LFUCacheTest.java
new file mode 100644
index 0000000..77195a8
--- /dev/null
+++ b/algorithm/src/test/java/dataStructureDesign/LFUCacheTest.java
@@ -0,0 +1,23 @@
+package dataStructureDesign;
+
+import org.junit.Test;
+
+public class LFUCacheTest {
+
+    LFUCache solver = new LFUCache(2);
+
+    @Test
+    public void testOne() {
+        solver.put(1,1);
+        solver.put(2,2);
+//        solver.put(10,10);
+        System.out.println(solver.get(1)); // 1
+        solver.put(3,3);
+        System.out.println(solver.get(2));
+        System.out.println(solver.get(3));
+        solver.put(4,4);
+        System.out.println(solver.get(1)); // -1
+        System.out.println(solver.get(3)); // 3
+        System.out.println(solver.get(4)); // 4
+    }
+}
diff --git a/algorithm/src/test/java/dataStructureDesign/LRUCache2Test.java b/algorithm/src/test/java/dataStructureDesign/LRUCache2Test.java
new file mode 100644
index 0000000..9e37d95
--- /dev/null
+++ b/algorithm/src/test/java/dataStructureDesign/LRUCache2Test.java
@@ -0,0 +1,34 @@
+package dataStructureDesign;
+
+import org.junit.Test;
+
+public class LRUCache2Test {
+
+    LRUCache2 solver = new LRUCache2(2);
+
+    @Test
+    public void testOne() {
+        solver.put(1,1);
+        solver.put(2,2);
+        System.out.println(solver.get(1)); // 1
+        solver.put(3,3);
+        System.out.println(solver.get(2)); // -1
+        solver.put(4,4);
+        System.out.println(solver.get(1)); // -1
+        System.out.println(solver.get(3)); // 3
+        System.out.println(solver.get(4)); // 4
+    }
+
+    @Test
+    public void testTwo() {
+        solver.put(1,1);
+        solver.put(2,2);
+        System.out.println(solver.get(1)); // 1
+        solver.put(3,3);
+        System.out.println(solver.get(2)); // -1
+        solver.put(4,4);
+        System.out.println(solver.get(1)); // -1
+        System.out.println(solver.get(3)); // 3
+        System.out.println(solver.get(4)); // 4
+    }
+}
diff --git a/algorithm/src/test/java/dataStructureDesign/LRUCacheTest.java b/algorithm/src/test/java/dataStructureDesign/LRUCacheTest.java
new file mode 100644
index 0000000..e3dccdd
--- /dev/null
+++ b/algorithm/src/test/java/dataStructureDesign/LRUCacheTest.java
@@ -0,0 +1,34 @@
+package dataStructureDesign;
+
+import org.junit.Test;
+
+public class LRUCacheTest {
+
+    LRUCache solver = new LRUCache(2);
+
+    @Test
+    public void testOne() {
+        solver.put(1,1);
+        solver.put(2,2);
+        System.out.println(solver.get(1)); // 1
+        solver.put(3,3);
+        System.out.println(solver.get(2)); // -1
+        solver.put(4,4);
+        System.out.println(solver.get(1)); // -1
+        System.out.println(solver.get(3)); // 3
+        System.out.println(solver.get(4)); // 4
+    }
+
+    @Test
+    public void testTwo() {
+        solver.put(1,1);
+        solver.put(2,2);
+        System.out.println(solver.get(1)); // 1
+        solver.put(3,3);
+        System.out.println(solver.get(2)); // -1
+        solver.put(4,4);
+        System.out.println(solver.get(1)); // -1
+        System.out.println(solver.get(3)); // 3
+        System.out.println(solver.get(4)); // 4
+    }
+}
diff --git a/algorithm/src/test/java/differenceArray/CarPoolingTest.java b/algorithm/src/test/java/differenceArray/CarPoolingTest.java
new file mode 100644
index 0000000..87d43cb
--- /dev/null
+++ b/algorithm/src/test/java/differenceArray/CarPoolingTest.java
@@ -0,0 +1,29 @@
+package differenceArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CarPoolingTest {
+
+    private CarPooling pool = new CarPooling();
+
+    @Test
+    public void test1() {
+        int[][] nums = new int[][]{
+                {2,1,5},
+                {3,3,7}
+        };
+        boolean res = pool.carPooling(nums, 4);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void test2() {
+        int[][] nums = new int[][]{
+                {2,1,5},
+                {3,3,7}
+        };
+        boolean res = pool.carPooling(nums, 5);
+        Assert.assertTrue(res);
+    }
+}
diff --git a/algorithm/src/test/java/differenceArray/FlightBookingTest.java b/algorithm/src/test/java/differenceArray/FlightBookingTest.java
new file mode 100644
index 0000000..440c44b
--- /dev/null
+++ b/algorithm/src/test/java/differenceArray/FlightBookingTest.java
@@ -0,0 +1,21 @@
+package differenceArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FlightBookingTest {
+
+    private FlightBooking book = new FlightBooking();
+
+    @Test
+    public void test1() {
+        int[][] bookings = new int[][]{
+                {1,2,10},
+                {2,3,20},
+                {2,5,25}
+        };
+
+        int[] res = book.flightBooking(bookings, 5);
+        Assert.assertArrayEquals(new int[]{10,55,45,25,25}, res);
+    }
+}
diff --git a/algorithm/src/test/java/differenceArray/RangeAddTest.java b/algorithm/src/test/java/differenceArray/RangeAddTest.java
new file mode 100644
index 0000000..d3f6a03
--- /dev/null
+++ b/algorithm/src/test/java/differenceArray/RangeAddTest.java
@@ -0,0 +1,21 @@
+package differenceArray;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RangeAddTest {
+
+    private RangeAdd add = new RangeAdd();
+
+    @Test
+    public void test1() {
+        int[][] nums = new int[][] {
+                {1,3,2},
+                {2,4,3},
+                {0,2,-2}
+        };
+
+        int[] res = add.rangeAdd(nums, 5);
+        Assert.assertArrayEquals(new int[]{-2,0,3,5,3}, res);
+    }
+}
diff --git a/algorithm/src/test/java/graphTherory/AllPathListTest.java b/algorithm/src/test/java/graphTherory/AllPathListTest.java
new file mode 100644
index 0000000..d0fc687
--- /dev/null
+++ b/algorithm/src/test/java/graphTherory/AllPathListTest.java
@@ -0,0 +1,4 @@
+package graphTherory;
+
+public class AllPathListTest {
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbers2Test.java b/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbers2Test.java
new file mode 100644
index 0000000..ec9acd0
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbers2Test.java
@@ -0,0 +1,79 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AddTwoNumbers2Test {
+
+    private AddTwoNumbers2 add = new AddTwoNumbers2();
+
+    public ListNode numsToListNode(int[] nums) {
+        ListNode dummy = new ListNode(-1);
+
+        // 创建链表
+        ListNode p = dummy;
+        for(int n : nums) {
+            p.next = new ListNode(n);
+            p = p.next;
+        }
+        return dummy.next;
+    }
+
+    public int[] listNodeToNums(ListNode l) {
+        int size = 0;
+        ListNode p = l;
+        while(l!=null) {
+            size++;
+            l = l.next;
+        }
+        int[] nums = new int[size];
+
+        size=0;
+        l = p;
+        while(l!=null) {
+            nums[size] = l.val;
+            l = l.next;
+            size++;
+        }
+        return nums;
+    }
+
+    @Test
+    public void test1() {
+        int[] nums1 = new int[] {3,4,2};
+        int[] nums2 = new int[] {4,6,5};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{8,0,7}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums1 = new int[] {0};
+        int[] nums2 = new int[] {0};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{0}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums1 = new int[] {9,9,9,9,9,9,9};
+        int[] nums2 = new int[] {9,9,9,9};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{1,0,0,0,9,9,9,8}, res);
+    }
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbersTest.java b/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbersTest.java
new file mode 100644
index 0000000..4bf252d
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/AddTwoNumbersTest.java
@@ -0,0 +1,79 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class AddTwoNumbersTest {
+
+    private AddTwoNumbers add = new AddTwoNumbers();
+
+    public ListNode numsToListNode(int[] nums) {
+        ListNode dummy = new ListNode(-1);
+
+        // 创建链表
+        ListNode p = dummy;
+        for(int n : nums) {
+            p.next = new ListNode(n);
+            p = p.next;
+        }
+        return dummy.next;
+    }
+
+    public int[] listNodeToNums(ListNode l) {
+        int size = 0;
+        ListNode p = l;
+        while(l!=null) {
+            size++;
+            l = l.next;
+        }
+        int[] nums = new int[size];
+
+        size=0;
+        l = p;
+        while(l!=null) {
+            nums[size] = l.val;
+            l = l.next;
+            size++;
+        }
+        return nums;
+    }
+
+    @Test
+    public void test1() {
+        int[] nums1 = new int[] {2,4,3};
+        int[] nums2 = new int[] {5,6,4};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{7,0,8}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums1 = new int[] {0};
+        int[] nums2 = new int[] {0};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{0}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums1 = new int[] {9,9,9,9,9,9,9};
+        int[] nums2 = new int[] {9,9,9,9};
+        ListNode l1 = numsToListNode(nums1);
+        ListNode l2 = numsToListNode(nums2);
+
+        ListNode list = add.addTwoNumbers(l1, l2);
+
+        int[] res = listNodeToNums(list);
+        Assert.assertArrayEquals(new int[]{8,9,9,9,0,0,0,1}, res);
+    }
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/DeleteNthNodeTest.java b/algorithm/src/test/java/linkedList/doublePointer/DeleteNthNodeTest.java
new file mode 100644
index 0000000..3bcd1b7
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/DeleteNthNodeTest.java
@@ -0,0 +1,27 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DeleteNthNodeTest {
+
+    private DeleteNthNode list = new DeleteNthNode();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {1,2,3,4,5};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resList = list.deleteNthNode(l, 6);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,3,4,5}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[] {1,2,3,4,5};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resList = list.deleteNthNode(l, 2);
+        int[] res = ListNode.listNodeToNum(resList);
+        Assert.assertArrayEquals(new int[]{1,2,3,5}, res);
+    }
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleIITest.java b/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleIITest.java
new file mode 100644
index 0000000..1a7b10b
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleIITest.java
@@ -0,0 +1,46 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LinkedListCycleIITest {
+
+    private LinkedListCycleII cycle = new LinkedListCycleII();
+
+    public ListNode numsToListNode(int[] nums, int pos) {
+        ListNode dummy = new ListNode(-1);
+        ListNode temp= new ListNode(-1);
+
+        // 创建链表
+        ListNode p = dummy;
+        for(int i=0; i<nums.length; i++) {
+            p.next = new ListNode(nums[i]);
+            p = p.next;
+            if(pos==i) {
+                temp = p;
+            }
+        }
+
+        if(0<= pos && pos<nums.length) {
+            p.next = temp;
+        }
+        return dummy.next;
+    }
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{3,2,0,-4};
+        ListNode list = numsToListNode(nums, 1);
+        int pos = cycle.linkedListCycle(list);
+        Assert.assertEquals(1, pos);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[]{3,2,0,-4};
+        ListNode list = numsToListNode(nums, -1);
+        int pos = cycle.linkedListCycle(list);
+        Assert.assertEquals(-1, pos);
+    }
+
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleTest.java b/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleTest.java
new file mode 100644
index 0000000..6cc3772
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/LinkedListCycleTest.java
@@ -0,0 +1,50 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LinkedListCycleTest {
+
+    private LinkedListCycle cycle = new LinkedListCycle();
+
+    public ListNode numsToListNode(int[] nums, int pos) {
+        ListNode dummy = new ListNode(-1);
+        ListNode temp= new ListNode(-1);
+
+        // 创建链表
+        ListNode p = dummy;
+        for(int i=0; i<nums.length; i++) {
+            p.next = new ListNode(nums[i]);
+            p = p.next;
+            if(pos==i) {
+                temp = p;
+            }
+        }
+
+        if(0<= pos && pos<nums.length) {
+            p.next = temp;
+        }
+        return dummy.next;
+    }
+
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{3,2,0,-4};
+        ListNode list = numsToListNode(nums, 1);
+        boolean cy = cycle.linkedListCycle(list);
+        Assert.assertTrue(cy);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[]{3,2,0,-4};
+        ListNode list = numsToListNode(nums, -1);
+        boolean cy = cycle.linkedListCycle(list);
+        Assert.assertFalse(cy);
+    }
+
+
+
+
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/LinkedListIntersectTest.java b/algorithm/src/test/java/linkedList/doublePointer/LinkedListIntersectTest.java
new file mode 100644
index 0000000..b83e4fc
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/LinkedListIntersectTest.java
@@ -0,0 +1,4 @@
+package linkedList.doublePointer;
+
+public class LinkedListIntersectTest {
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/MergeKSortedListTest.java b/algorithm/src/test/java/linkedList/doublePointer/MergeKSortedListTest.java
new file mode 100644
index 0000000..a0ad2bd
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/MergeKSortedListTest.java
@@ -0,0 +1,39 @@
+package linkedList.doublePointer;
+
+/**
+ * 23. 合并K个有序链表
+ */
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MergeKSortedListTest {
+    private MergeKSortedList list = new MergeKSortedList();
+
+    @Test
+    public void test1() {
+        int[] nums1 = new int[] {1,4,5};
+        int[] nums2 = new int[] {1,3,4};
+        int[] nums3 = new int[] {2,6};
+        ListNode l1 = ListNode.numsToListNode(nums1);
+        ListNode l2 = ListNode.numsToListNode(nums2);
+        ListNode l3 = ListNode.numsToListNode(nums3);
+        ListNode resListNode = list.mergeKListNode(new ListNode[] {l1,l2,l3});
+        int[] res = ListNode.listNodeToNum(resListNode);
+        Assert.assertArrayEquals(new int[]{1,1,2,3,4,4,5,6}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums1 = new int[] {};
+        int[] nums2 = new int[] {};
+        int[] nums3 = new int[] {};
+        ListNode l1 = ListNode.numsToListNode(nums1);
+        ListNode l2 = ListNode.numsToListNode(nums2);
+        ListNode l3 = ListNode.numsToListNode(nums3);
+        ListNode resListNode = list.mergeKListNode(new ListNode[] {l1,l2,l3});
+        int[] res = ListNode.listNodeToNum(resListNode);
+        Assert.assertArrayEquals(new int[]{}, res);
+    }
+
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/MergeSortedListTest.java b/algorithm/src/test/java/linkedList/doublePointer/MergeSortedListTest.java
new file mode 100644
index 0000000..f5f0324
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/MergeSortedListTest.java
@@ -0,0 +1,43 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+
+public class MergeSortedListTest {
+
+    private MergeSortedList merge = new MergeSortedList();
+
+    @Test
+    public void test1() {
+        int[] nums1 = new int[] {1,2,4};
+        int[] nums2 = new int[] {1,3,4};
+        ListNode l1 = ListNode.numsToListNode(nums1);
+        ListNode l2 = ListNode.numsToListNode(nums2);
+        ListNode m = merge.mergeSortedList(l1, l2);
+        int[] res = ListNode.listNodeToNum(m);
+        Assert.assertArrayEquals(new int[]{1,1,2,3,4,4}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums1 = new int[] {};
+        int[] nums2 = new int[] {};
+        ListNode l1 = ListNode.numsToListNode(nums1);
+        ListNode l2 = ListNode.numsToListNode(nums2);
+        ListNode m = merge.mergeSortedList(l1, l2);
+        int[] res = ListNode.listNodeToNum(m);
+        Assert.assertArrayEquals(new int[]{}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums1 = new int[] {};
+        int[] nums2 = new int[] {0};
+        ListNode l1 = ListNode.numsToListNode(nums1);
+        ListNode l2 = ListNode.numsToListNode(nums2);
+        ListNode m = merge.mergeSortedList(l1, l2);
+        int[] res = ListNode.listNodeToNum(m);
+        Assert.assertArrayEquals(new int[]{0}, res);
+    }
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/MiddleNodeTest.java b/algorithm/src/test/java/linkedList/doublePointer/MiddleNodeTest.java
new file mode 100644
index 0000000..9bdf7d4
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/MiddleNodeTest.java
@@ -0,0 +1,29 @@
+package linkedList.doublePointer;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MiddleNodeTest {
+
+    private MiddleNode middle = new MiddleNode();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {1,2,3,4,5};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resNode = middle.middleNode(l);
+        int[] res = ListNode.listNodeToNum(resNode);
+        Assert.assertArrayEquals(new int[]{3,4,5}, res);
+
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[] {1,2,3,4,5,6};
+        ListNode l = ListNode.numsToListNode(nums);
+        ListNode resNode = middle.middleNode(l);
+        int[] res = ListNode.listNodeToNum(resNode);
+        Assert.assertArrayEquals(new int[]{4,5,6}, res);
+
+    }
+}
diff --git a/algorithm/src/test/java/linkedList/doublePointer/RemoveDuplicateTest.java b/algorithm/src/test/java/linkedList/doublePointer/RemoveDuplicateTest.java
new file mode 100644
index 0000000..57f7bfd
--- /dev/null
+++ b/algorithm/src/test/java/linkedList/doublePointer/RemoveDuplicateTest.java
@@ -0,0 +1,43 @@
+package linkedList.doublePointer;
+
+/**
+ * 23. 合并K个有序链表
+ */
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RemoveDuplicateTest {
+    private RemoveDuplicate re = new RemoveDuplicate();
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {1,4,5};
+        ListNode list = ListNode.numsToListNode(nums);
+
+        ListNode resListNode = re.remove(list);
+        int[] res = ListNode.listNodeToNum(resListNode);
+        Assert.assertArrayEquals(new int[]{1,4,5}, res);
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = new int[] {1,1,3,4,4,5};
+        ListNode list = ListNode.numsToListNode(nums);
+
+        ListNode resListNode = re.remove(list);
+        int[] res = ListNode.listNodeToNum(resListNode);
+        Assert.assertArrayEquals(new int[]{1,3,4,5}, res);
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = new int[] {};
+        ListNode list = ListNode.numsToListNode(nums);
+
+        ListNode resListNode = re.remove(list);
+        int[] res = ListNode.listNodeToNum(resListNode);
+        Assert.assertArrayEquals(new int[]{}, res);
+    }
+
+}
diff --git a/algorithm/src/test/java/nSum/NSumTest.java b/algorithm/src/test/java/nSum/NSumTest.java
new file mode 100644
index 0000000..81df7e5
--- /dev/null
+++ b/algorithm/src/test/java/nSum/NSumTest.java
@@ -0,0 +1,87 @@
+package nSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class NSumTest {
+
+    @Test
+    public void testNSum() {
+        int[][] nums = new int[][]{
+                {},
+                {1,5,3,2},
+                {1,1,2,2,2,3,3,4},
+                {2,2,2,2,2,2,2,2,2,2}
+        };
+
+        int[][][] expect = new int[][][]{
+                {{}},
+                {{1,2,3}},
+                {{1,3,4},{2,2,4}},
+                {{2,2,2}}
+        };
+
+        int[] target = new int[]{
+                0,
+                6,
+                8,
+                6
+        };
+
+        NSum solution = new NSum();
+        for(int i=0;i<nums.length;i++) {
+            ArrayList<ArrayList<Integer>> res = solution.nSum(nums[i], target[i], 3);
+            assertNSum(res, expect[i], 3);
+        }
+    }
+
+    @Test
+    public void testNSum2() {
+        int[][] nums = new int[][]{
+                {},
+                {1,5,3,2},
+                {1,1,2,2,2,3,3,4,4},
+                {2,2,2,2,2,2,2,2,2,2}
+        };
+
+        int[][][] expect = new int[][][]{
+                {{}},
+                {{1,2,3}},
+                {{1,1,4,4},{2,2,3,3}},
+                {{2,2,2,2,2,2}}
+        };
+
+        int[] target = new int[]{
+                0,
+                10,
+                10,
+                12
+        };
+
+        int []N = new int[] {
+                0,
+                3,
+                4,
+                6
+        };
+
+        NSum solution = new NSum();
+        for(int i=0;i<nums.length;i++) {
+            ArrayList<ArrayList<Integer>> res = solution.nSum(nums[i], target[i], N[i]);
+            assertNSum(res, expect[i], N[i]);
+        }
+
+    }
+
+    private void assertNSum(ArrayList<ArrayList<Integer>>res, int[][] expect,int n) {
+        for(int i=0;i<res.size();i++) {
+            int[] temp = new int[n];
+            for(int j=0;j<res.get(i).size();j++) {
+                temp[j] = res.get(i).get(j);
+            }
+            Assert.assertArrayEquals(temp, expect[i]);
+        }
+    }
+}
diff --git a/algorithm/src/test/java/nSum/ThreeSumTest.java b/algorithm/src/test/java/nSum/ThreeSumTest.java
new file mode 100644
index 0000000..c18a41e
--- /dev/null
+++ b/algorithm/src/test/java/nSum/ThreeSumTest.java
@@ -0,0 +1,52 @@
+package nSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class ThreeSumTest {
+
+    @Test
+    public void testThreeSum() {
+        int[][] nums = new int[][]{
+                {},
+                {1,5,3,2},
+                {1,1,2,2,2,3,3,4},
+                {2,2,2,2,2,2,2,2,2,2}
+        };
+
+        int[][][] expect = new int[][][]{
+                {{}},
+                {{1,2,3}},
+                {{1,3,4},{2,2,4}},
+                {{2,2,2}}
+        };
+
+        int[] target = new int[]{
+                0,
+                6,
+                8,
+                6
+        };
+
+        ThreeSum solution = new ThreeSum();
+        for(int i=0;i<nums.length;i++) {
+            ArrayList<ArrayList<Integer>> res = solution.threeSum(nums[i], target[i]);
+            assertNSum(res, expect[i], 3);
+        }
+
+
+
+    }
+
+    private void assertNSum(ArrayList<ArrayList<Integer>>res, int[][] expect,int n) {
+        for(int i=0;i<res.size();i++) {
+            int[] temp = new int[n];
+            for(int j=0;j<res.get(i).size();j++) {
+                temp[j] = res.get(i).get(j);
+            }
+            Assert.assertArrayEquals(temp, expect[i]);
+        }
+    }
+}
diff --git a/algorithm/src/test/java/nSum/TwoSumTest.java b/algorithm/src/test/java/nSum/TwoSumTest.java
new file mode 100644
index 0000000..95878ef
--- /dev/null
+++ b/algorithm/src/test/java/nSum/TwoSumTest.java
@@ -0,0 +1,52 @@
+package nSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class TwoSumTest {
+
+    @Test
+    public void testTwoSum() {
+        int[][] nums = new int[][]{
+                {},
+                {1,5,3,2},
+                {1,1,2,2,2,3,3,4},
+                {2,2,2,2,2,2,2,2,2,2}
+        };
+
+        int[][][] expect = new int[][][]{
+                {{}},
+                {{2,3}},
+                {{1,3},{2,2}},
+                {{2,2}}
+        };
+
+        int[] target = new int[]{
+                0,
+                5,
+                4,
+                4
+        };
+
+        TwoSum solution = new TwoSum();
+        for(int i=0;i<nums.length;i++) {
+            ArrayList<ArrayList<Integer>> res = solution.twoSum(nums[i], target[i]);
+            assertNSum(res, expect[i], 2);
+        }
+
+
+
+    }
+
+    private void assertNSum(ArrayList<ArrayList<Integer>>res, int[][] expect,int n) {
+        for(int i=0;i<res.size();i++) {
+            int[] temp = new int[n];
+            for(int j=0;j<res.get(i).size();j++) {
+                temp[j] = res.get(i).get(j);
+            }
+            Assert.assertArrayEquals(temp, expect[i]);
+        }
+    }
+}
diff --git a/algorithm/src/test/java/other/IsIsomorphicTest.java b/algorithm/src/test/java/other/IsIsomorphicTest.java
new file mode 100644
index 0000000..bc00644
--- /dev/null
+++ b/algorithm/src/test/java/other/IsIsomorphicTest.java
@@ -0,0 +1,25 @@
+package other;
+
+import org.junit.Test;
+
+public class IsIsomorphicTest {
+    IsIsomorphic solver = new IsIsomorphic();
+
+    @Test
+    public void testOne() {
+        String s = "badc";
+        String t = "babc";
+        boolean res = solver.isIsomorphic(s, t);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void testTwo() {
+        String s = "paper";
+        String t = "title";
+        boolean res = solver.isIsomorphic(s, t);
+        System.out.println(res);
+        // true
+    }
+}
diff --git a/algorithm/src/test/java/prefixSum/MatrixSumTest.java b/algorithm/src/test/java/prefixSum/MatrixSumTest.java
new file mode 100644
index 0000000..502a603
--- /dev/null
+++ b/algorithm/src/test/java/prefixSum/MatrixSumTest.java
@@ -0,0 +1,27 @@
+package prefixSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MatrixSumTest {
+
+    private MatrixSum sum = new MatrixSum();
+
+    @Test
+    public void test1() {
+        int[][] nums = new int[][] {
+                {1,2,3},
+                {4,5,6},
+                {7,8,9}
+        };
+
+        int[][] res = sum.matrixSum(nums, 1);
+        int[][] expected = new int[][] {
+                {12,21,16},
+                {27,45,33},
+                {24,39,28}
+        };
+
+        Assert.assertArrayEquals(expected, res);
+    }
+}
diff --git a/algorithm/src/test/java/prefixSum/NumArrayTest.java b/algorithm/src/test/java/prefixSum/NumArrayTest.java
new file mode 100644
index 0000000..9ec4d9e
--- /dev/null
+++ b/algorithm/src/test/java/prefixSum/NumArrayTest.java
@@ -0,0 +1,23 @@
+package prefixSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NumArrayTest {
+
+    @Test
+    public void test1() {
+        int[] nums = new int[] {-2, 0, 3, -5, 2, -1};
+        NumArray array = new NumArray(nums);
+        int res;
+        res = array.sumRange(0,2);
+        Assert.assertEquals(1, res);
+
+        res = array.sumRange(2,5);
+        Assert.assertEquals(-1, res);
+
+        res = array.sumRange(0,5);
+        Assert.assertEquals(-3, res);
+    }
+
+}
diff --git a/algorithm/src/test/java/prefixSum/NumMatrixTest.java b/algorithm/src/test/java/prefixSum/NumMatrixTest.java
new file mode 100644
index 0000000..9d2ddcf
--- /dev/null
+++ b/algorithm/src/test/java/prefixSum/NumMatrixTest.java
@@ -0,0 +1,34 @@
+package prefixSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class NumMatrixTest {
+
+    int[][] nums = new int[][] {
+            {3,0,1,4,2},
+            {5,6,3,2,1},
+            {1,2,0,1,5},
+            {4,1,0,1,7},
+            {1,0,3,0,5}
+    };
+    private NumMatrix matrix = new NumMatrix(nums);
+
+    @Test
+    public void test1() {
+        int res = matrix.sumRegion(2,1,4,3);
+        Assert.assertEquals(8, res);
+    }
+
+    @Test
+    public void test2() {
+        int res = matrix.sumRegion(1,1,2,2);
+        Assert.assertEquals(11, res);
+    }
+
+    @Test
+    public void test3() {
+        int res = matrix.sumRegion(1,2,2,4);
+        Assert.assertEquals(12, res);
+    }
+}
diff --git a/algorithm/src/test/java/prefixSum/ProductOfNumbersTest.java b/algorithm/src/test/java/prefixSum/ProductOfNumbersTest.java
new file mode 100644
index 0000000..09022ce
--- /dev/null
+++ b/algorithm/src/test/java/prefixSum/ProductOfNumbersTest.java
@@ -0,0 +1,32 @@
+package prefixSum;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ProductOfNumbersTest {
+
+    private ProductOfNumbers product = new ProductOfNumbers();
+
+    @Test
+    public void test1() {
+        product.add(3);
+        product.add(0);
+        product.add(2);
+        product.add(5);
+        product.add(4);
+        int res;
+        res = product.getProduct(2);
+        Assert.assertEquals(20, res);
+
+        res = product.getProduct(3);
+        Assert.assertEquals(40, res);
+
+        res = product.getProduct(4);
+        Assert.assertEquals(0, res);
+
+
+        product.add(8);
+        res = product.getProduct(2);
+        Assert.assertEquals(32, res);
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/EvalRPNTest.java b/algorithm/src/test/java/stack_queue/EvalRPNTest.java
new file mode 100644
index 0000000..5d4deaa
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/EvalRPNTest.java
@@ -0,0 +1,33 @@
+package stack_queue;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EvalRPNTest {
+
+    private EvalRPN eval = new EvalRPN();
+
+    @Test
+    public void test1() {
+        String[] tokens = new String[] {"2","1","+","3","*"};
+        int res = eval.evalRPN(tokens);
+        Assert.assertEquals(9, res);
+    }
+
+    @Test
+    public void test2() {
+        String[] tokens = new String[] {"4","13","5","/","+"};
+        int res = eval.evalRPN(tokens);
+        Assert.assertEquals(6, res);
+    }
+
+    @Test
+    public void test3() {
+        String[] tokens = new String[] {"10","6","9","3","+","-11","*","/","*","17","+","5","+"};
+        int res = eval.evalRPN(tokens);
+        Assert.assertEquals(22, res);
+    }
+
+
+
+
+}
diff --git a/algorithm/src/test/java/stack_queue/ImplementQueueUsingStacksTest.java b/algorithm/src/test/java/stack_queue/ImplementQueueUsingStacksTest.java
new file mode 100644
index 0000000..cecade1
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/ImplementQueueUsingStacksTest.java
@@ -0,0 +1,22 @@
+package stack_queue;
+
+import org.junit.Test;
+
+public class ImplementQueueUsingStacksTest {
+
+    ImplementQueueUsingStacks solver = new ImplementQueueUsingStacks();
+
+    @Test
+    public void testOne() {
+        solver.push(1);
+        solver.push(2);
+        solver.push(3);
+        System.out.println(solver.peek());
+        solver.pop();
+        System.out.println(solver.peek());
+        solver.pop();
+        System.out.println(solver.peek());
+        solver.pop();
+        System.out.println(solver.peek());
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/ImplementStackUsingQueuesTest.java b/algorithm/src/test/java/stack_queue/ImplementStackUsingQueuesTest.java
new file mode 100644
index 0000000..da53428
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/ImplementStackUsingQueuesTest.java
@@ -0,0 +1,23 @@
+package stack_queue;
+
+import org.junit.Test;
+
+public class ImplementStackUsingQueuesTest {
+
+    ImplementStackUsingQueues solver = new ImplementStackUsingQueues();
+
+    @Test
+    public void testOne() {
+        solver.push(1);
+        solver.push(2);
+        solver.push(3);
+        System.out.println(solver.peek()); // 3
+        solver.pop();
+        System.out.println(solver.peek()); // 2
+        solver.pop();
+        System.out.println(solver.peek()); // 1
+        solver.pop();
+        System.out.println(solver.peek()); // -1
+
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/LongestValidParenthesesTest.java b/algorithm/src/test/java/stack_queue/LongestValidParenthesesTest.java
new file mode 100644
index 0000000..0f96e1e
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/LongestValidParenthesesTest.java
@@ -0,0 +1,37 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LongestValidParenthesesTest {
+
+    LongestValidParentheses longest = new LongestValidParentheses();
+
+    @Test
+    public void test1() {
+        String s = new String("(()");
+        int res = longest.longestValidParentheses(s);
+        Assert.assertEquals(2, res);
+    }
+
+    @Test
+    public void test2() {
+        String s = new String(")()())");
+        int res = longest.longestValidParentheses(s);
+        Assert.assertEquals(4, res);
+    }
+
+    @Test
+    public void test3() {
+        String s = new String("");
+        int res = longest.longestValidParentheses(s);
+        Assert.assertEquals(0, res);
+    }
+
+    @Test
+    public void test4() {
+        String s = new String("(())((()");
+        int res = longest.longestValidParentheses(s);
+        Assert.assertEquals(4, res);
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/MinAddMakeValidTest.java b/algorithm/src/test/java/stack_queue/MinAddMakeValidTest.java
new file mode 100644
index 0000000..af137d7
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/MinAddMakeValidTest.java
@@ -0,0 +1,30 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MinAddMakeValidTest {
+
+    private MinAddMakeValid add = new MinAddMakeValid();
+
+    @Test
+    public void test1() {
+        String s = new String("())");
+        int res = add.minAddMakeValid(s);
+        Assert.assertEquals(1, res);
+    }
+
+    @Test
+    public void test2() {
+        String s = new String("(((");
+        int res = add.minAddMakeValid(s);
+        Assert.assertEquals(3, res);
+    }
+
+    @Test
+    public void test3() {
+        String s = new String(")))");
+        int res = add.minAddMakeValid(s);
+        Assert.assertEquals(3, res);
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/MinStackTest.java b/algorithm/src/test/java/stack_queue/MinStackTest.java
new file mode 100644
index 0000000..d9bed48
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/MinStackTest.java
@@ -0,0 +1,32 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Stack;
+
+public class MinStackTest {
+
+    private MinStack min = new MinStack();
+
+    @Test
+    public void tet1() {
+        int res;
+
+        min.push(-2);
+        min.push(0);
+        min.push(-3);
+
+        res = min.getMin();
+        Assert.assertEquals(-3, res);
+
+        min.pop();
+        min.pop();
+        res = min.getMin();
+        Assert.assertEquals(-2, res);
+
+    }
+
+
+
+}
diff --git a/algorithm/src/test/java/stack_queue/MinimumInsertionsToBalanceParenthesesTest.java b/algorithm/src/test/java/stack_queue/MinimumInsertionsToBalanceParenthesesTest.java
new file mode 100644
index 0000000..79793ae
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/MinimumInsertionsToBalanceParenthesesTest.java
@@ -0,0 +1,30 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MinimumInsertionsToBalanceParenthesesTest {
+
+    private MinimumInsertionsToBalanceParentheses min = new MinimumInsertionsToBalanceParentheses();
+
+    @Test
+    public void test1() {
+        String s = new String("(()))");
+        int res = min.minInsert(s);
+        Assert.assertEquals(1, res);
+    }
+
+    @Test
+    public void test2() {
+        String s = new String("()))((");
+        int res = min.minInsert(s);
+        Assert.assertEquals(6, res);
+    }
+
+    @Test
+    public void test3() {
+        String s = new String("))())(");
+        int res = min.minInsert(s);
+        Assert.assertEquals(3, res);
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/QueueTest.java b/algorithm/src/test/java/stack_queue/QueueTest.java
new file mode 100644
index 0000000..a221d49
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/QueueTest.java
@@ -0,0 +1,55 @@
+package stack_queue;
+
+import org.junit.Test;
+
+import java.util.PriorityQueue;
+
+
+
+public class QueueTest {
+
+
+
+    // 从小到大排列
+    PriorityQueue<QueueNode> queue = new PriorityQueue<>(
+            (o1, o2) -> {
+                return o1.val - o2.val;
+            }
+    );
+
+    @Test
+    public void testOne() {
+        QueueNode n1 = new QueueNode(1);
+        QueueNode n2 = new QueueNode(2);
+        queue.add(n1);
+        queue.add(n2);
+        assert queue.peek() != null;
+        System.out.println(queue.peek().val); // 1
+        n1.val = 5;
+        assert queue.peek() != null;
+        System.out.println(queue.peek().val); // 5
+    }
+
+    @Test
+    public void testTwo() {
+        QueueNode n1 = new QueueNode(1);
+        QueueNode n2 = new QueueNode(2);
+        queue.add(n1);
+        queue.add(n2);
+        assert queue.peek() != null;
+        n1.val = 5;
+        assert queue.peek() != null;
+        System.out.println(queue.poll().val); // 5
+    }
+
+
+    class QueueNode {
+    int val;
+
+    public QueueNode(int val) {
+        this.val = val;
+    }
+}
+
+
+}
diff --git a/algorithm/src/test/java/stack_queue/SimplifyPathTest.java b/algorithm/src/test/java/stack_queue/SimplifyPathTest.java
new file mode 100644
index 0000000..1af36a4
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/SimplifyPathTest.java
@@ -0,0 +1,41 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SimplifyPathTest {
+
+    private SimplifyPath simple = new SimplifyPath();
+
+    @Test
+    public void test1() {
+        String path = new String("/home/");
+        String res = simple.simplifyPath(path);
+        String expect = new String("/home");
+        Assert.assertEquals(expect, res);
+    }
+
+    @Test
+    public void test2() {
+        String path = new String("/.../");
+        String res = simple.simplifyPath(path);
+        String expect = new String("/...");
+        Assert.assertEquals(expect, res);
+    }
+
+    @Test
+    public void test3() {
+        String path = new String("/../");
+        String res = simple.simplifyPath(path);
+        String expect = new String("/");
+        Assert.assertEquals(expect, res);
+    }
+
+    @Test
+    public void test4() {
+        String path = new String("/home//foo/");
+        String res = simple.simplifyPath(path);
+        String expect = new String("/home/foo");
+        Assert.assertEquals(expect, res);
+    }
+}
diff --git a/algorithm/src/test/java/stack_queue/SlidingWindowMaxTest.java b/algorithm/src/test/java/stack_queue/SlidingWindowMaxTest.java
new file mode 100644
index 0000000..4211395
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/SlidingWindowMaxTest.java
@@ -0,0 +1,22 @@
+package stack_queue;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SlidingWindowMaxTest {
+
+    private SlidingWindowMax max = new SlidingWindowMax();
+
+
+    @Test
+    public void test1() {
+        int[] nums = new int[]{1,3,-1,-3,5,3,6,7};
+        int k =3;
+        int[] expect = new int[] {3,3,5,5,6,7};
+        int[] res = max.slidingWindowMax(nums, k);
+        Assert.assertArrayEquals(expect, res);
+    }
+
+
+
+}
diff --git a/algorithm/src/test/java/stack_queue/ValidParenthesesTest.java b/algorithm/src/test/java/stack_queue/ValidParenthesesTest.java
new file mode 100644
index 0000000..f32cd2b
--- /dev/null
+++ b/algorithm/src/test/java/stack_queue/ValidParenthesesTest.java
@@ -0,0 +1,40 @@
+package stack_queue;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ValidParenthesesTest {
+
+    private ValidParentheses valid = new ValidParentheses();
+
+    @Test
+    public void test1() {
+        String s = new String("([)]");
+        boolean res = valid.validParentheses(s);
+        Assert.assertFalse(res);
+    }
+
+    @Test
+    public void test2() {
+        String s = new String("()[]{}");
+        boolean res = valid.validParentheses(s);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test3() {
+        String s = new String("()");
+        boolean res = valid.validParentheses(s);
+        Assert.assertTrue(res);
+    }
+
+    @Test
+    public void test4() {
+        String s = new String("(]");
+        boolean res = valid.validParentheses(s);
+        Assert.assertFalse(res);
+    }
+
+
+}
diff --git a/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversal.class b/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversal.class
new file mode 100644
index 0000000..1476690
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversalII.class b/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversalII.class
new file mode 100644
index 0000000..02bdc97
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/BinaryTreeLevelOrderTraversalII.class differ
diff --git a/algorithm/target/classes/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.class b/algorithm/target/classes/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.class
new file mode 100644
index 0000000..c34358c
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/BinaryTreeZigzagLevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/BFS_DFS/CountSubIslands.class b/algorithm/target/classes/BFS_DFS/CountSubIslands.class
new file mode 100644
index 0000000..7bc29cd
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/CountSubIslands.class differ
diff --git a/algorithm/target/classes/BFS_DFS/MaxAreaIsland.class b/algorithm/target/classes/BFS_DFS/MaxAreaIsland.class
new file mode 100644
index 0000000..865460d
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/MaxAreaIsland.class differ
diff --git a/algorithm/target/classes/BFS_DFS/MinimumDepthBinaryTree.class b/algorithm/target/classes/BFS_DFS/MinimumDepthBinaryTree.class
new file mode 100644
index 0000000..132c49d
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/MinimumDepthBinaryTree.class differ
diff --git a/algorithm/target/classes/BFS_DFS/NumberClosedIslands.class b/algorithm/target/classes/BFS_DFS/NumberClosedIslands.class
new file mode 100644
index 0000000..01e92e2
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/NumberClosedIslands.class differ
diff --git a/algorithm/target/classes/BFS_DFS/NumberDistinctIslands.class b/algorithm/target/classes/BFS_DFS/NumberDistinctIslands.class
new file mode 100644
index 0000000..ccd4fd9
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/NumberDistinctIslands.class differ
diff --git a/algorithm/target/classes/BFS_DFS/NumberEnclaves.class b/algorithm/target/classes/BFS_DFS/NumberEnclaves.class
new file mode 100644
index 0000000..cafc28f
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/NumberEnclaves.class differ
diff --git a/algorithm/target/classes/BFS_DFS/NumberIslands.class b/algorithm/target/classes/BFS_DFS/NumberIslands.class
new file mode 100644
index 0000000..cfb20ee
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/NumberIslands.class differ
diff --git a/algorithm/target/classes/BFS_DFS/OpenTheLock.class b/algorithm/target/classes/BFS_DFS/OpenTheLock.class
new file mode 100644
index 0000000..68cc6e7
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/OpenTheLock.class differ
diff --git a/algorithm/target/classes/BFS_DFS/SlidingPuzzle.class b/algorithm/target/classes/BFS_DFS/SlidingPuzzle.class
new file mode 100644
index 0000000..abb28a5
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/SlidingPuzzle.class differ
diff --git a/algorithm/target/classes/BFS_DFS/SurroundedRegions.class b/algorithm/target/classes/BFS_DFS/SurroundedRegions.class
new file mode 100644
index 0000000..3814af4
Binary files /dev/null and b/algorithm/target/classes/BFS_DFS/SurroundedRegions.class differ
diff --git a/algorithm/target/classes/DP/BloodSimilarity.class b/algorithm/target/classes/DP/BloodSimilarity.class
new file mode 100644
index 0000000..132ede6
Binary files /dev/null and b/algorithm/target/classes/DP/BloodSimilarity.class differ
diff --git a/algorithm/target/classes/DP/DisjointLines.class b/algorithm/target/classes/DP/DisjointLines.class
new file mode 100644
index 0000000..61ea209
Binary files /dev/null and b/algorithm/target/classes/DP/DisjointLines.class differ
diff --git a/algorithm/target/classes/DP/Envelops$1.class b/algorithm/target/classes/DP/Envelops$1.class
new file mode 100644
index 0000000..497db5c
Binary files /dev/null and b/algorithm/target/classes/DP/Envelops$1.class differ
diff --git a/algorithm/target/classes/DP/Envelops.class b/algorithm/target/classes/DP/Envelops.class
new file mode 100644
index 0000000..bd9067f
Binary files /dev/null and b/algorithm/target/classes/DP/Envelops.class differ
diff --git a/algorithm/target/classes/DP/IsSubsequence.class b/algorithm/target/classes/DP/IsSubsequence.class
new file mode 100644
index 0000000..16cab78
Binary files /dev/null and b/algorithm/target/classes/DP/IsSubsequence.class differ
diff --git a/algorithm/target/classes/DP/LongestCommonSubsequence.class b/algorithm/target/classes/DP/LongestCommonSubsequence.class
new file mode 100644
index 0000000..0b956df
Binary files /dev/null and b/algorithm/target/classes/DP/LongestCommonSubsequence.class differ
diff --git a/algorithm/target/classes/DP/LongestCommonSubsequenceII.class b/algorithm/target/classes/DP/LongestCommonSubsequenceII.class
new file mode 100644
index 0000000..d1b2744
Binary files /dev/null and b/algorithm/target/classes/DP/LongestCommonSubsequenceII.class differ
diff --git a/algorithm/target/classes/DP/MinFallingPathSum.class b/algorithm/target/classes/DP/MinFallingPathSum.class
new file mode 100644
index 0000000..2c7e430
Binary files /dev/null and b/algorithm/target/classes/DP/MinFallingPathSum.class differ
diff --git a/algorithm/target/classes/DP/MinFallingPathSum2.class b/algorithm/target/classes/DP/MinFallingPathSum2.class
new file mode 100644
index 0000000..30390c3
Binary files /dev/null and b/algorithm/target/classes/DP/MinFallingPathSum2.class differ
diff --git a/algorithm/target/classes/DP/MinFallingPathSumII.class b/algorithm/target/classes/DP/MinFallingPathSumII.class
new file mode 100644
index 0000000..88c7018
Binary files /dev/null and b/algorithm/target/classes/DP/MinFallingPathSumII.class differ
diff --git a/algorithm/target/classes/DP/MinPathSum.class b/algorithm/target/classes/DP/MinPathSum.class
new file mode 100644
index 0000000..6438dc9
Binary files /dev/null and b/algorithm/target/classes/DP/MinPathSum.class differ
diff --git a/algorithm/target/classes/DP/MinimumTriangleTotal.class b/algorithm/target/classes/DP/MinimumTriangleTotal.class
new file mode 100644
index 0000000..4bfd8fd
Binary files /dev/null and b/algorithm/target/classes/DP/MinimumTriangleTotal.class differ
diff --git a/algorithm/target/classes/DP/MinimumTriangleTotalII.class b/algorithm/target/classes/DP/MinimumTriangleTotalII.class
new file mode 100644
index 0000000..03c3205
Binary files /dev/null and b/algorithm/target/classes/DP/MinimumTriangleTotalII.class differ
diff --git a/algorithm/target/classes/DP/PalindromeList.class b/algorithm/target/classes/DP/PalindromeList.class
new file mode 100644
index 0000000..3e9eb46
Binary files /dev/null and b/algorithm/target/classes/DP/PalindromeList.class differ
diff --git a/algorithm/target/classes/DP/ReverseNode.class b/algorithm/target/classes/DP/ReverseNode.class
new file mode 100644
index 0000000..c1cd290
Binary files /dev/null and b/algorithm/target/classes/DP/ReverseNode.class differ
diff --git a/algorithm/target/classes/DP/ReverseNode2.class b/algorithm/target/classes/DP/ReverseNode2.class
new file mode 100644
index 0000000..efbe7ef
Binary files /dev/null and b/algorithm/target/classes/DP/ReverseNode2.class differ
diff --git a/algorithm/target/classes/DP/ReverseNode3.class b/algorithm/target/classes/DP/ReverseNode3.class
new file mode 100644
index 0000000..20d46c8
Binary files /dev/null and b/algorithm/target/classes/DP/ReverseNode3.class differ
diff --git a/algorithm/target/classes/DP/ReverseNodeKGroup.class b/algorithm/target/classes/DP/ReverseNodeKGroup.class
new file mode 100644
index 0000000..568efaa
Binary files /dev/null and b/algorithm/target/classes/DP/ReverseNodeKGroup.class differ
diff --git a/algorithm/target/classes/DP/RussianDollEnvelopes$1.class b/algorithm/target/classes/DP/RussianDollEnvelopes$1.class
new file mode 100644
index 0000000..5bce931
Binary files /dev/null and b/algorithm/target/classes/DP/RussianDollEnvelopes$1.class differ
diff --git a/algorithm/target/classes/DP/RussianDollEnvelopes.class b/algorithm/target/classes/DP/RussianDollEnvelopes.class
new file mode 100644
index 0000000..d77b373
Binary files /dev/null and b/algorithm/target/classes/DP/RussianDollEnvelopes.class differ
diff --git a/algorithm/target/classes/DP/UniquePathsWithObstacles.class b/algorithm/target/classes/DP/UniquePathsWithObstacles.class
new file mode 100644
index 0000000..e29ece5
Binary files /dev/null and b/algorithm/target/classes/DP/UniquePathsWithObstacles.class differ
diff --git a/algorithm/target/classes/alibaba/DuplicateLength.class b/algorithm/target/classes/alibaba/DuplicateLength.class
new file mode 100644
index 0000000..3a44fa8
Binary files /dev/null and b/algorithm/target/classes/alibaba/DuplicateLength.class differ
diff --git a/algorithm/target/classes/alibaba/ThreadPrintABC$1.class b/algorithm/target/classes/alibaba/ThreadPrintABC$1.class
new file mode 100644
index 0000000..ac6eae0
Binary files /dev/null and b/algorithm/target/classes/alibaba/ThreadPrintABC$1.class differ
diff --git a/algorithm/target/classes/alibaba/ThreadPrintABC.class b/algorithm/target/classes/alibaba/ThreadPrintABC.class
new file mode 100644
index 0000000..6a6a663
Binary files /dev/null and b/algorithm/target/classes/alibaba/ThreadPrintABC.class differ
diff --git a/algorithm/target/classes/alibaba/ThreadPrintABC2.class b/algorithm/target/classes/alibaba/ThreadPrintABC2.class
new file mode 100644
index 0000000..c4a0573
Binary files /dev/null and b/algorithm/target/classes/alibaba/ThreadPrintABC2.class differ
diff --git a/algorithm/target/classes/alibaba/ThreadPrintCharNum.class b/algorithm/target/classes/alibaba/ThreadPrintCharNum.class
new file mode 100644
index 0000000..f5e9cf3
Binary files /dev/null and b/algorithm/target/classes/alibaba/ThreadPrintCharNum.class differ
diff --git a/algorithm/target/classes/alibaba/ThreadPrintNums.class b/algorithm/target/classes/alibaba/ThreadPrintNums.class
new file mode 100644
index 0000000..c12a0dd
Binary files /dev/null and b/algorithm/target/classes/alibaba/ThreadPrintNums.class differ
diff --git a/algorithm/target/classes/array/binarySearch/EatBanana.class b/algorithm/target/classes/array/binarySearch/EatBanana.class
new file mode 100644
index 0000000..4fb96a9
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/EatBanana.class differ
diff --git a/algorithm/target/classes/array/binarySearch/IsSubsequence.class b/algorithm/target/classes/array/binarySearch/IsSubsequence.class
new file mode 100644
index 0000000..64dc3d9
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/IsSubsequence.class differ
diff --git a/algorithm/target/classes/array/binarySearch/PeakArray.class b/algorithm/target/classes/array/binarySearch/PeakArray.class
new file mode 100644
index 0000000..25f2932
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/PeakArray.class differ
diff --git a/algorithm/target/classes/array/binarySearch/PreimageSizeZF.class b/algorithm/target/classes/array/binarySearch/PreimageSizeZF.class
new file mode 100644
index 0000000..e55726e
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/PreimageSizeZF.class differ
diff --git a/algorithm/target/classes/array/binarySearch/SearchInsertPosition.class b/algorithm/target/classes/array/binarySearch/SearchInsertPosition.class
new file mode 100644
index 0000000..7fe028e
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/SearchInsertPosition.class differ
diff --git a/algorithm/target/classes/array/binarySearch/SearchMatrix.class b/algorithm/target/classes/array/binarySearch/SearchMatrix.class
new file mode 100644
index 0000000..ab6750d
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/SearchMatrix.class differ
diff --git a/algorithm/target/classes/array/binarySearch/SearchPosition.class b/algorithm/target/classes/array/binarySearch/SearchPosition.class
new file mode 100644
index 0000000..e832eb8
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/SearchPosition.class differ
diff --git a/algorithm/target/classes/array/binarySearch/SearchRange.class b/algorithm/target/classes/array/binarySearch/SearchRange.class
new file mode 100644
index 0000000..6bb7e39
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/SearchRange.class differ
diff --git a/algorithm/target/classes/array/binarySearch/ShipWithinDays.class b/algorithm/target/classes/array/binarySearch/ShipWithinDays.class
new file mode 100644
index 0000000..5699dd9
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/ShipWithinDays.class differ
diff --git a/algorithm/target/classes/array/binarySearch/TailingZeros.class b/algorithm/target/classes/array/binarySearch/TailingZeros.class
new file mode 100644
index 0000000..81d2ebf
Binary files /dev/null and b/algorithm/target/classes/array/binarySearch/TailingZeros.class differ
diff --git a/algorithm/target/classes/array/other/AdvantageShuffle.class b/algorithm/target/classes/array/other/AdvantageShuffle.class
new file mode 100644
index 0000000..298de29
Binary files /dev/null and b/algorithm/target/classes/array/other/AdvantageShuffle.class differ
diff --git a/algorithm/target/classes/array/other/ContainerWithMostWater.class b/algorithm/target/classes/array/other/ContainerWithMostWater.class
new file mode 100644
index 0000000..320acf1
Binary files /dev/null and b/algorithm/target/classes/array/other/ContainerWithMostWater.class differ
diff --git a/algorithm/target/classes/array/other/IntervalListIntersections.class b/algorithm/target/classes/array/other/IntervalListIntersections.class
new file mode 100644
index 0000000..a771bbf
Binary files /dev/null and b/algorithm/target/classes/array/other/IntervalListIntersections.class differ
diff --git a/algorithm/target/classes/array/other/MaxRepeatSubString.class b/algorithm/target/classes/array/other/MaxRepeatSubString.class
new file mode 100644
index 0000000..6d6b03b
Binary files /dev/null and b/algorithm/target/classes/array/other/MaxRepeatSubString.class differ
diff --git a/algorithm/target/classes/array/other/RemoveDuplicateSortedArray.class b/algorithm/target/classes/array/other/RemoveDuplicateSortedArray.class
new file mode 100644
index 0000000..d3477fa
Binary files /dev/null and b/algorithm/target/classes/array/other/RemoveDuplicateSortedArray.class differ
diff --git a/algorithm/target/classes/array/other/Search2DMatrixII.class b/algorithm/target/classes/array/other/Search2DMatrixII.class
new file mode 100644
index 0000000..411a910
Binary files /dev/null and b/algorithm/target/classes/array/other/Search2DMatrixII.class differ
diff --git a/algorithm/target/classes/array/other/SquaresSortedArray.class b/algorithm/target/classes/array/other/SquaresSortedArray.class
new file mode 100644
index 0000000..d65a199
Binary files /dev/null and b/algorithm/target/classes/array/other/SquaresSortedArray.class differ
diff --git a/algorithm/target/classes/array/other/TrappingRainWater.class b/algorithm/target/classes/array/other/TrappingRainWater.class
new file mode 100644
index 0000000..e96618d
Binary files /dev/null and b/algorithm/target/classes/array/other/TrappingRainWater.class differ
diff --git a/algorithm/target/classes/array/other/TwoSumLessThanK.class b/algorithm/target/classes/array/other/TwoSumLessThanK.class
new file mode 100644
index 0000000..9108429
Binary files /dev/null and b/algorithm/target/classes/array/other/TwoSumLessThanK.class differ
diff --git a/algorithm/target/classes/array/slideWindow/FindAnagrams.class b/algorithm/target/classes/array/slideWindow/FindAnagrams.class
new file mode 100644
index 0000000..f3196e2
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/FindAnagrams.class differ
diff --git a/algorithm/target/classes/array/slideWindow/LengthOfLongestSubstring.class b/algorithm/target/classes/array/slideWindow/LengthOfLongestSubstring.class
new file mode 100644
index 0000000..f6683e8
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/LengthOfLongestSubstring.class differ
diff --git a/algorithm/target/classes/array/slideWindow/MinWindowSubstring.class b/algorithm/target/classes/array/slideWindow/MinWindowSubstring.class
new file mode 100644
index 0000000..09f91b2
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/MinWindowSubstring.class differ
diff --git a/algorithm/target/classes/array/slideWindow/MinimumWindow.class b/algorithm/target/classes/array/slideWindow/MinimumWindow.class
new file mode 100644
index 0000000..7187567
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/MinimumWindow.class differ
diff --git a/algorithm/target/classes/array/slideWindow/MonotonicMinQueue.class b/algorithm/target/classes/array/slideWindow/MonotonicMinQueue.class
new file mode 100644
index 0000000..63205c6
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/MonotonicMinQueue.class differ
diff --git a/algorithm/target/classes/array/slideWindow/MonotonicQueue.class b/algorithm/target/classes/array/slideWindow/MonotonicQueue.class
new file mode 100644
index 0000000..00ce37c
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/MonotonicQueue.class differ
diff --git a/algorithm/target/classes/array/slideWindow/Permutation.class b/algorithm/target/classes/array/slideWindow/Permutation.class
new file mode 100644
index 0000000..02fc055
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/Permutation.class differ
diff --git a/algorithm/target/classes/array/slideWindow/SlidingWindowMaximum.class b/algorithm/target/classes/array/slideWindow/SlidingWindowMaximum.class
new file mode 100644
index 0000000..73bd5ce
Binary files /dev/null and b/algorithm/target/classes/array/slideWindow/SlidingWindowMaximum.class differ
diff --git a/algorithm/target/classes/backTrack/CombinationSum.class b/algorithm/target/classes/backTrack/CombinationSum.class
new file mode 100644
index 0000000..52d5f69
Binary files /dev/null and b/algorithm/target/classes/backTrack/CombinationSum.class differ
diff --git a/algorithm/target/classes/backTrack/Combinations.class b/algorithm/target/classes/backTrack/Combinations.class
new file mode 100644
index 0000000..ad6afe1
Binary files /dev/null and b/algorithm/target/classes/backTrack/Combinations.class differ
diff --git a/algorithm/target/classes/backTrack/GenerateParentheses.class b/algorithm/target/classes/backTrack/GenerateParentheses.class
new file mode 100644
index 0000000..f7c071d
Binary files /dev/null and b/algorithm/target/classes/backTrack/GenerateParentheses.class differ
diff --git a/algorithm/target/classes/backTrack/MaximumDepthBinaryTree.class b/algorithm/target/classes/backTrack/MaximumDepthBinaryTree.class
new file mode 100644
index 0000000..d23e89e
Binary files /dev/null and b/algorithm/target/classes/backTrack/MaximumDepthBinaryTree.class differ
diff --git a/algorithm/target/classes/backTrack/NQueues.class b/algorithm/target/classes/backTrack/NQueues.class
new file mode 100644
index 0000000..33bcf2c
Binary files /dev/null and b/algorithm/target/classes/backTrack/NQueues.class differ
diff --git a/algorithm/target/classes/backTrack/PartitionKEqualSumSubsets.class b/algorithm/target/classes/backTrack/PartitionKEqualSumSubsets.class
new file mode 100644
index 0000000..4042c5b
Binary files /dev/null and b/algorithm/target/classes/backTrack/PartitionKEqualSumSubsets.class differ
diff --git a/algorithm/target/classes/backTrack/Permutations.class b/algorithm/target/classes/backTrack/Permutations.class
new file mode 100644
index 0000000..4452349
Binary files /dev/null and b/algorithm/target/classes/backTrack/Permutations.class differ
diff --git a/algorithm/target/classes/backTrack/Subsets.class b/algorithm/target/classes/backTrack/Subsets.class
new file mode 100644
index 0000000..5932bec
Binary files /dev/null and b/algorithm/target/classes/backTrack/Subsets.class differ
diff --git a/algorithm/target/classes/backTrack/SudokuSolver.class b/algorithm/target/classes/backTrack/SudokuSolver.class
new file mode 100644
index 0000000..d42eec1
Binary files /dev/null and b/algorithm/target/classes/backTrack/SudokuSolver.class differ
diff --git a/algorithm/target/classes/backTrack/TargetSum.class b/algorithm/target/classes/backTrack/TargetSum.class
new file mode 100644
index 0000000..1d58ced
Binary files /dev/null and b/algorithm/target/classes/backTrack/TargetSum.class differ
diff --git a/algorithm/target/classes/backTrack/TargetSum2.class b/algorithm/target/classes/backTrack/TargetSum2.class
new file mode 100644
index 0000000..04ea430
Binary files /dev/null and b/algorithm/target/classes/backTrack/TargetSum2.class differ
diff --git a/algorithm/target/classes/binaryHeap/KthLargestData.class b/algorithm/target/classes/binaryHeap/KthLargestData.class
new file mode 100644
index 0000000..65e5e57
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/KthLargestData.class differ
diff --git a/algorithm/target/classes/binaryHeap/KthLargestElement.class b/algorithm/target/classes/binaryHeap/KthLargestElement.class
new file mode 100644
index 0000000..8494e68
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/KthLargestElement.class differ
diff --git a/algorithm/target/classes/binaryHeap/MaxFrequency.class b/algorithm/target/classes/binaryHeap/MaxFrequency.class
new file mode 100644
index 0000000..9eb4b6a
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/MaxFrequency.class differ
diff --git a/algorithm/target/classes/binaryHeap/MedianData.class b/algorithm/target/classes/binaryHeap/MedianData.class
new file mode 100644
index 0000000..6d47840
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/MedianData.class differ
diff --git a/algorithm/target/classes/binaryHeap/MinStack.class b/algorithm/target/classes/binaryHeap/MinStack.class
new file mode 100644
index 0000000..4917abf
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/MinStack.class differ
diff --git a/algorithm/target/classes/binaryHeap/SeatReserve.class b/algorithm/target/classes/binaryHeap/SeatReserve.class
new file mode 100644
index 0000000..d38f71d
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/SeatReserve.class differ
diff --git a/algorithm/target/classes/binaryHeap/SingleThreadCPU$1Task.class b/algorithm/target/classes/binaryHeap/SingleThreadCPU$1Task.class
new file mode 100644
index 0000000..7fd7969
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/SingleThreadCPU$1Task.class differ
diff --git a/algorithm/target/classes/binaryHeap/SingleThreadCPU.class b/algorithm/target/classes/binaryHeap/SingleThreadCPU.class
new file mode 100644
index 0000000..9bd4dc3
Binary files /dev/null and b/algorithm/target/classes/binaryHeap/SingleThreadCPU.class differ
diff --git a/algorithm/target/classes/binaryTree/BinaryTreeLevelOrderTraversal.class b/algorithm/target/classes/binaryTree/BinaryTreeLevelOrderTraversal.class
new file mode 100644
index 0000000..281b407
Binary files /dev/null and b/algorithm/target/classes/binaryTree/BinaryTreeLevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/binaryTree/BinaryTreePostorderTraversal.class b/algorithm/target/classes/binaryTree/BinaryTreePostorderTraversal.class
new file mode 100644
index 0000000..703b6a8
Binary files /dev/null and b/algorithm/target/classes/binaryTree/BinaryTreePostorderTraversal.class differ
diff --git a/algorithm/target/classes/binaryTree/BinaryTreeZigzagLevelOrderTraversal.class b/algorithm/target/classes/binaryTree/BinaryTreeZigzagLevelOrderTraversal.class
new file mode 100644
index 0000000..4d7ab75
Binary files /dev/null and b/algorithm/target/classes/binaryTree/BinaryTreeZigzagLevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/binaryTree/DiameterBinaryTree.class b/algorithm/target/classes/binaryTree/DiameterBinaryTree.class
new file mode 100644
index 0000000..61a59b2
Binary files /dev/null and b/algorithm/target/classes/binaryTree/DiameterBinaryTree.class differ
diff --git a/algorithm/target/classes/binaryTree/FlattenBinaryTreeToLinkedList.class b/algorithm/target/classes/binaryTree/FlattenBinaryTreeToLinkedList.class
new file mode 100644
index 0000000..95e9314
Binary files /dev/null and b/algorithm/target/classes/binaryTree/FlattenBinaryTreeToLinkedList.class differ
diff --git a/algorithm/target/classes/binaryTree/InorderTraversal.class b/algorithm/target/classes/binaryTree/InorderTraversal.class
new file mode 100644
index 0000000..f2b15de
Binary files /dev/null and b/algorithm/target/classes/binaryTree/InorderTraversal.class differ
diff --git a/algorithm/target/classes/binaryTree/InvertBinaryTree.class b/algorithm/target/classes/binaryTree/InvertBinaryTree.class
new file mode 100644
index 0000000..a351636
Binary files /dev/null and b/algorithm/target/classes/binaryTree/InvertBinaryTree.class differ
diff --git a/algorithm/target/classes/binaryTree/LevelOrderTraversal.class b/algorithm/target/classes/binaryTree/LevelOrderTraversal.class
new file mode 100644
index 0000000..9c9f7d9
Binary files /dev/null and b/algorithm/target/classes/binaryTree/LevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/binaryTree/MaximumDepth.class b/algorithm/target/classes/binaryTree/MaximumDepth.class
new file mode 100644
index 0000000..8f29a06
Binary files /dev/null and b/algorithm/target/classes/binaryTree/MaximumDepth.class differ
diff --git a/algorithm/target/classes/binaryTree/MaximumDepthNTree.class b/algorithm/target/classes/binaryTree/MaximumDepthNTree.class
new file mode 100644
index 0000000..642e318
Binary files /dev/null and b/algorithm/target/classes/binaryTree/MaximumDepthNTree.class differ
diff --git a/algorithm/target/classes/binaryTree/MinimumDepthBinaryTree.class b/algorithm/target/classes/binaryTree/MinimumDepthBinaryTree.class
new file mode 100644
index 0000000..c95f288
Binary files /dev/null and b/algorithm/target/classes/binaryTree/MinimumDepthBinaryTree.class differ
diff --git a/algorithm/target/classes/binaryTree/SameTree.class b/algorithm/target/classes/binaryTree/SameTree.class
new file mode 100644
index 0000000..bcfa13e
Binary files /dev/null and b/algorithm/target/classes/binaryTree/SameTree.class differ
diff --git a/algorithm/target/classes/binaryTree/SameTree2.class b/algorithm/target/classes/binaryTree/SameTree2.class
new file mode 100644
index 0000000..cfc50fa
Binary files /dev/null and b/algorithm/target/classes/binaryTree/SameTree2.class differ
diff --git a/algorithm/target/classes/binaryTree/SerializeAndDeserializeBinaryTree.class b/algorithm/target/classes/binaryTree/SerializeAndDeserializeBinaryTree.class
new file mode 100644
index 0000000..dabba46
Binary files /dev/null and b/algorithm/target/classes/binaryTree/SerializeAndDeserializeBinaryTree.class differ
diff --git a/algorithm/target/classes/binaryTree/TreeNode.class b/algorithm/target/classes/binaryTree/TreeNode.class
new file mode 100644
index 0000000..5c7db63
Binary files /dev/null and b/algorithm/target/classes/binaryTree/TreeNode.class differ
diff --git a/algorithm/target/classes/binaryTree/ZigzagLevelOrderTraversal.class b/algorithm/target/classes/binaryTree/ZigzagLevelOrderTraversal.class
new file mode 100644
index 0000000..d615def
Binary files /dev/null and b/algorithm/target/classes/binaryTree/ZigzagLevelOrderTraversal.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/InsertDeleteGetRandom.class b/algorithm/target/classes/dataStructureDesign/InsertDeleteGetRandom.class
new file mode 100644
index 0000000..cbfd557
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/InsertDeleteGetRandom.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/LFUCache.class b/algorithm/target/classes/dataStructureDesign/LFUCache.class
new file mode 100644
index 0000000..755a9f1
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/LFUCache.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/LFUNode.class b/algorithm/target/classes/dataStructureDesign/LFUNode.class
new file mode 100644
index 0000000..dcee982
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/LFUNode.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/LRUCache.class b/algorithm/target/classes/dataStructureDesign/LRUCache.class
new file mode 100644
index 0000000..91277e7
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/LRUCache.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/LRUCache2.class b/algorithm/target/classes/dataStructureDesign/LRUCache2.class
new file mode 100644
index 0000000..6f3e2de
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/LRUCache2.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/MaximumFrequencyStack.class b/algorithm/target/classes/dataStructureDesign/MaximumFrequencyStack.class
new file mode 100644
index 0000000..814aa82
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/MaximumFrequencyStack.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/MinStack.class b/algorithm/target/classes/dataStructureDesign/MinStack.class
new file mode 100644
index 0000000..527d712
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/MinStack.class differ
diff --git a/algorithm/target/classes/dataStructureDesign/Node.class b/algorithm/target/classes/dataStructureDesign/Node.class
new file mode 100644
index 0000000..da486f9
Binary files /dev/null and b/algorithm/target/classes/dataStructureDesign/Node.class differ
diff --git a/algorithm/target/classes/differenceArray/CarPooling.class b/algorithm/target/classes/differenceArray/CarPooling.class
new file mode 100644
index 0000000..151bb3e
Binary files /dev/null and b/algorithm/target/classes/differenceArray/CarPooling.class differ
diff --git a/algorithm/target/classes/differenceArray/FlightBooking.class b/algorithm/target/classes/differenceArray/FlightBooking.class
new file mode 100644
index 0000000..78891bb
Binary files /dev/null and b/algorithm/target/classes/differenceArray/FlightBooking.class differ
diff --git a/algorithm/target/classes/differenceArray/RangeAdd.class b/algorithm/target/classes/differenceArray/RangeAdd.class
new file mode 100644
index 0000000..5bd10a4
Binary files /dev/null and b/algorithm/target/classes/differenceArray/RangeAdd.class differ
diff --git a/algorithm/target/classes/graphTheory/AllPathList.class b/algorithm/target/classes/graphTheory/AllPathList.class
new file mode 100644
index 0000000..5b2f4d0
Binary files /dev/null and b/algorithm/target/classes/graphTheory/AllPathList.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers.class b/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers.class
new file mode 100644
index 0000000..ce693c7
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers2.class b/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers2.class
new file mode 100644
index 0000000..45a2655
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/AddTwoNumbers2.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/DeleteNthNode.class b/algorithm/target/classes/linkedList/doublePointer/DeleteNthNode.class
new file mode 100644
index 0000000..97cd533
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/DeleteNthNode.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/LinkedListCycle.class b/algorithm/target/classes/linkedList/doublePointer/LinkedListCycle.class
new file mode 100644
index 0000000..62a0c08
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/LinkedListCycle.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/LinkedListCycleII.class b/algorithm/target/classes/linkedList/doublePointer/LinkedListCycleII.class
new file mode 100644
index 0000000..d0451c5
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/LinkedListCycleII.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/LinkedListIntersect.class b/algorithm/target/classes/linkedList/doublePointer/LinkedListIntersect.class
new file mode 100644
index 0000000..7100f6a
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/LinkedListIntersect.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/ListNode.class b/algorithm/target/classes/linkedList/doublePointer/ListNode.class
new file mode 100644
index 0000000..298066b
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/ListNode.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/MergeKSortedList.class b/algorithm/target/classes/linkedList/doublePointer/MergeKSortedList.class
new file mode 100644
index 0000000..d4c4295
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/MergeKSortedList.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/MergeSortedList.class b/algorithm/target/classes/linkedList/doublePointer/MergeSortedList.class
new file mode 100644
index 0000000..4eee226
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/MergeSortedList.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/MiddleNode.class b/algorithm/target/classes/linkedList/doublePointer/MiddleNode.class
new file mode 100644
index 0000000..6cca9f1
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/MiddleNode.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/PalindromeLinkedList.class b/algorithm/target/classes/linkedList/doublePointer/PalindromeLinkedList.class
new file mode 100644
index 0000000..9cf546c
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/PalindromeLinkedList.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/RemoveDuplicate.class b/algorithm/target/classes/linkedList/doublePointer/RemoveDuplicate.class
new file mode 100644
index 0000000..6b047e9
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/RemoveDuplicate.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/ReverseLinkedListII.class b/algorithm/target/classes/linkedList/doublePointer/ReverseLinkedListII.class
new file mode 100644
index 0000000..3069671
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/ReverseLinkedListII.class differ
diff --git a/algorithm/target/classes/linkedList/doublePointer/ReverseNodesInKGroup.class b/algorithm/target/classes/linkedList/doublePointer/ReverseNodesInKGroup.class
new file mode 100644
index 0000000..5e219a7
Binary files /dev/null and b/algorithm/target/classes/linkedList/doublePointer/ReverseNodesInKGroup.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzz.class b/algorithm/target/classes/multiThread/FizzBuzz.class
new file mode 100644
index 0000000..598814a
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzz.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzzII$1.class b/algorithm/target/classes/multiThread/FizzBuzzII$1.class
new file mode 100644
index 0000000..b63e765
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzzII$1.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzzII$2.class b/algorithm/target/classes/multiThread/FizzBuzzII$2.class
new file mode 100644
index 0000000..352c105
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzzII$2.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzzII$3.class b/algorithm/target/classes/multiThread/FizzBuzzII$3.class
new file mode 100644
index 0000000..afe3914
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzzII$3.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzzII.class b/algorithm/target/classes/multiThread/FizzBuzzII.class
new file mode 100644
index 0000000..5bcf4bb
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzzII.class differ
diff --git a/algorithm/target/classes/multiThread/FizzBuzzIII.class b/algorithm/target/classes/multiThread/FizzBuzzIII.class
new file mode 100644
index 0000000..15dfc53
Binary files /dev/null and b/algorithm/target/classes/multiThread/FizzBuzzIII.class differ
diff --git a/algorithm/target/classes/multiThread/IntConsumer.class b/algorithm/target/classes/multiThread/IntConsumer.class
new file mode 100644
index 0000000..42d237d
Binary files /dev/null and b/algorithm/target/classes/multiThread/IntConsumer.class differ
diff --git a/algorithm/target/classes/multiThread/PrintFooBarAlternately$1.class b/algorithm/target/classes/multiThread/PrintFooBarAlternately$1.class
new file mode 100644
index 0000000..387eeb9
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintFooBarAlternately$1.class differ
diff --git a/algorithm/target/classes/multiThread/PrintFooBarAlternately$2.class b/algorithm/target/classes/multiThread/PrintFooBarAlternately$2.class
new file mode 100644
index 0000000..ecd3f84
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintFooBarAlternately$2.class differ
diff --git a/algorithm/target/classes/multiThread/PrintFooBarAlternately.class b/algorithm/target/classes/multiThread/PrintFooBarAlternately.class
new file mode 100644
index 0000000..0947bc3
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintFooBarAlternately.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder$1.class b/algorithm/target/classes/multiThread/PrintInOrder$1.class
new file mode 100644
index 0000000..94b621a
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder$1.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder$2.class b/algorithm/target/classes/multiThread/PrintInOrder$2.class
new file mode 100644
index 0000000..3e8df3e
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder$2.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder$3.class b/algorithm/target/classes/multiThread/PrintInOrder$3.class
new file mode 100644
index 0000000..cd597a8
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder$3.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder.class b/algorithm/target/classes/multiThread/PrintInOrder.class
new file mode 100644
index 0000000..742f22d
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder2$1.class b/algorithm/target/classes/multiThread/PrintInOrder2$1.class
new file mode 100644
index 0000000..771fc25
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder2$1.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder2$2.class b/algorithm/target/classes/multiThread/PrintInOrder2$2.class
new file mode 100644
index 0000000..50eb6ab
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder2$2.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder2$3.class b/algorithm/target/classes/multiThread/PrintInOrder2$3.class
new file mode 100644
index 0000000..d8aa571
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder2$3.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder2.class b/algorithm/target/classes/multiThread/PrintInOrder2.class
new file mode 100644
index 0000000..bbacdbf
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder2.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder3$1.class b/algorithm/target/classes/multiThread/PrintInOrder3$1.class
new file mode 100644
index 0000000..e4c2d72
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder3$1.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder3$2.class b/algorithm/target/classes/multiThread/PrintInOrder3$2.class
new file mode 100644
index 0000000..d185eb7
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder3$2.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder3$3.class b/algorithm/target/classes/multiThread/PrintInOrder3$3.class
new file mode 100644
index 0000000..d51879d
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder3$3.class differ
diff --git a/algorithm/target/classes/multiThread/PrintInOrder3.class b/algorithm/target/classes/multiThread/PrintInOrder3.class
new file mode 100644
index 0000000..ec96a1a
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintInOrder3.class differ
diff --git a/algorithm/target/classes/multiThread/PrintZeroOddEven.class b/algorithm/target/classes/multiThread/PrintZeroOddEven.class
new file mode 100644
index 0000000..db921c6
Binary files /dev/null and b/algorithm/target/classes/multiThread/PrintZeroOddEven.class differ
diff --git a/algorithm/target/classes/multiThread/ProduceH2O.class b/algorithm/target/classes/multiThread/ProduceH2O.class
new file mode 100644
index 0000000..f486732
Binary files /dev/null and b/algorithm/target/classes/multiThread/ProduceH2O.class differ
diff --git a/algorithm/target/classes/nSum/NSum.class b/algorithm/target/classes/nSum/NSum.class
new file mode 100644
index 0000000..390e5dc
Binary files /dev/null and b/algorithm/target/classes/nSum/NSum.class differ
diff --git a/algorithm/target/classes/nSum/ThreeSum.class b/algorithm/target/classes/nSum/ThreeSum.class
new file mode 100644
index 0000000..fadbe0b
Binary files /dev/null and b/algorithm/target/classes/nSum/ThreeSum.class differ
diff --git a/algorithm/target/classes/nSum/TwoSum.class b/algorithm/target/classes/nSum/TwoSum.class
new file mode 100644
index 0000000..c93ef7a
Binary files /dev/null and b/algorithm/target/classes/nSum/TwoSum.class differ
diff --git a/algorithm/target/classes/offer/Divide.class b/algorithm/target/classes/offer/Divide.class
new file mode 100644
index 0000000..c546aa1
Binary files /dev/null and b/algorithm/target/classes/offer/Divide.class differ
diff --git a/algorithm/target/classes/other/IsIsomorphic.class b/algorithm/target/classes/other/IsIsomorphic.class
new file mode 100644
index 0000000..c1e4f24
Binary files /dev/null and b/algorithm/target/classes/other/IsIsomorphic.class differ
diff --git a/algorithm/target/classes/prefixSum/MatrixSum.class b/algorithm/target/classes/prefixSum/MatrixSum.class
new file mode 100644
index 0000000..02ffd47
Binary files /dev/null and b/algorithm/target/classes/prefixSum/MatrixSum.class differ
diff --git a/algorithm/target/classes/prefixSum/NumArray.class b/algorithm/target/classes/prefixSum/NumArray.class
new file mode 100644
index 0000000..846c906
Binary files /dev/null and b/algorithm/target/classes/prefixSum/NumArray.class differ
diff --git a/algorithm/target/classes/prefixSum/NumMatrix.class b/algorithm/target/classes/prefixSum/NumMatrix.class
new file mode 100644
index 0000000..2aab758
Binary files /dev/null and b/algorithm/target/classes/prefixSum/NumMatrix.class differ
diff --git a/algorithm/target/classes/prefixSum/ProductOfNumbers.class b/algorithm/target/classes/prefixSum/ProductOfNumbers.class
new file mode 100644
index 0000000..fc48afd
Binary files /dev/null and b/algorithm/target/classes/prefixSum/ProductOfNumbers.class differ
diff --git a/algorithm/target/classes/stack_queue/EvalRPN.class b/algorithm/target/classes/stack_queue/EvalRPN.class
new file mode 100644
index 0000000..8c837e6
Binary files /dev/null and b/algorithm/target/classes/stack_queue/EvalRPN.class differ
diff --git a/algorithm/target/classes/stack_queue/ImplementQueueUsingStacks.class b/algorithm/target/classes/stack_queue/ImplementQueueUsingStacks.class
new file mode 100644
index 0000000..7591713
Binary files /dev/null and b/algorithm/target/classes/stack_queue/ImplementQueueUsingStacks.class differ
diff --git a/algorithm/target/classes/stack_queue/ImplementStackUsingQueues.class b/algorithm/target/classes/stack_queue/ImplementStackUsingQueues.class
new file mode 100644
index 0000000..98fe2d9
Binary files /dev/null and b/algorithm/target/classes/stack_queue/ImplementStackUsingQueues.class differ
diff --git a/algorithm/target/classes/stack_queue/LongestValidParentheses.class b/algorithm/target/classes/stack_queue/LongestValidParentheses.class
new file mode 100644
index 0000000..55366e4
Binary files /dev/null and b/algorithm/target/classes/stack_queue/LongestValidParentheses.class differ
diff --git a/algorithm/target/classes/stack_queue/MinAddMakeValid.class b/algorithm/target/classes/stack_queue/MinAddMakeValid.class
new file mode 100644
index 0000000..2134ccf
Binary files /dev/null and b/algorithm/target/classes/stack_queue/MinAddMakeValid.class differ
diff --git a/algorithm/target/classes/stack_queue/MinStack.class b/algorithm/target/classes/stack_queue/MinStack.class
new file mode 100644
index 0000000..0461855
Binary files /dev/null and b/algorithm/target/classes/stack_queue/MinStack.class differ
diff --git a/algorithm/target/classes/stack_queue/MinimumInsertionsToBalanceParentheses.class b/algorithm/target/classes/stack_queue/MinimumInsertionsToBalanceParentheses.class
new file mode 100644
index 0000000..e9273c7
Binary files /dev/null and b/algorithm/target/classes/stack_queue/MinimumInsertionsToBalanceParentheses.class differ
diff --git a/algorithm/target/classes/stack_queue/MonotonicQueue.class b/algorithm/target/classes/stack_queue/MonotonicQueue.class
new file mode 100644
index 0000000..2955e11
Binary files /dev/null and b/algorithm/target/classes/stack_queue/MonotonicQueue.class differ
diff --git a/algorithm/target/classes/stack_queue/SimplifyPath.class b/algorithm/target/classes/stack_queue/SimplifyPath.class
new file mode 100644
index 0000000..8444004
Binary files /dev/null and b/algorithm/target/classes/stack_queue/SimplifyPath.class differ
diff --git a/algorithm/target/classes/stack_queue/SlidingWindowMax.class b/algorithm/target/classes/stack_queue/SlidingWindowMax.class
new file mode 100644
index 0000000..267e5bc
Binary files /dev/null and b/algorithm/target/classes/stack_queue/SlidingWindowMax.class differ
diff --git a/algorithm/target/classes/stack_queue/ValidParentheses.class b/algorithm/target/classes/stack_queue/ValidParentheses.class
new file mode 100644
index 0000000..95c6991
Binary files /dev/null and b/algorithm/target/classes/stack_queue/ValidParentheses.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.class b/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.class
new file mode 100644
index 0000000..476cdea
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalIITest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalTest.class b/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalTest.class
new file mode 100644
index 0000000..e2f1988
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/BinaryTreeLevelOrderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.class b/algorithm/target/test-classes/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.class
new file mode 100644
index 0000000..1b2a736
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/BinaryTreeZigzagLevelOrderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/CountSubIslandsTest.class b/algorithm/target/test-classes/BSF_DSF/CountSubIslandsTest.class
new file mode 100644
index 0000000..00d0a12
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/CountSubIslandsTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/MaxAreaIslandTest.class b/algorithm/target/test-classes/BSF_DSF/MaxAreaIslandTest.class
new file mode 100644
index 0000000..477b399
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/MaxAreaIslandTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/MinimumDepthBinaryTreeTest.class b/algorithm/target/test-classes/BSF_DSF/MinimumDepthBinaryTreeTest.class
new file mode 100644
index 0000000..b15ff85
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/MinimumDepthBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/NumberClosedIslandsTest.class b/algorithm/target/test-classes/BSF_DSF/NumberClosedIslandsTest.class
new file mode 100644
index 0000000..1c700e6
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/NumberClosedIslandsTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/NumberDistinctIslandsTest.class b/algorithm/target/test-classes/BSF_DSF/NumberDistinctIslandsTest.class
new file mode 100644
index 0000000..d946ded
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/NumberDistinctIslandsTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/NumberEnclavesTest.class b/algorithm/target/test-classes/BSF_DSF/NumberEnclavesTest.class
new file mode 100644
index 0000000..ca16b22
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/NumberEnclavesTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/NumberIslandsTest.class b/algorithm/target/test-classes/BSF_DSF/NumberIslandsTest.class
new file mode 100644
index 0000000..e75f06f
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/NumberIslandsTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/OpenTheLockTest.class b/algorithm/target/test-classes/BSF_DSF/OpenTheLockTest.class
new file mode 100644
index 0000000..8f8e2ab
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/OpenTheLockTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/SlidingPuzzleTest.class b/algorithm/target/test-classes/BSF_DSF/SlidingPuzzleTest.class
new file mode 100644
index 0000000..bdf4044
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/SlidingPuzzleTest.class differ
diff --git a/algorithm/target/test-classes/BSF_DSF/SurroundedRegionsTest.class b/algorithm/target/test-classes/BSF_DSF/SurroundedRegionsTest.class
new file mode 100644
index 0000000..991d9c0
Binary files /dev/null and b/algorithm/target/test-classes/BSF_DSF/SurroundedRegionsTest.class differ
diff --git a/algorithm/target/test-classes/DP/BloodSimilarityTest.class b/algorithm/target/test-classes/DP/BloodSimilarityTest.class
new file mode 100644
index 0000000..a5b738e
Binary files /dev/null and b/algorithm/target/test-classes/DP/BloodSimilarityTest.class differ
diff --git a/algorithm/target/test-classes/DP/DisjointLinesTest.class b/algorithm/target/test-classes/DP/DisjointLinesTest.class
new file mode 100644
index 0000000..150a261
Binary files /dev/null and b/algorithm/target/test-classes/DP/DisjointLinesTest.class differ
diff --git a/algorithm/target/test-classes/DP/EnvelopsTest.class b/algorithm/target/test-classes/DP/EnvelopsTest.class
new file mode 100644
index 0000000..0a0f9a0
Binary files /dev/null and b/algorithm/target/test-classes/DP/EnvelopsTest.class differ
diff --git a/algorithm/target/test-classes/DP/IsSubsequenceTest.class b/algorithm/target/test-classes/DP/IsSubsequenceTest.class
new file mode 100644
index 0000000..cf64d7f
Binary files /dev/null and b/algorithm/target/test-classes/DP/IsSubsequenceTest.class differ
diff --git a/algorithm/target/test-classes/DP/LongestCommonSubsequenceIITest.class b/algorithm/target/test-classes/DP/LongestCommonSubsequenceIITest.class
new file mode 100644
index 0000000..644a4c1
Binary files /dev/null and b/algorithm/target/test-classes/DP/LongestCommonSubsequenceIITest.class differ
diff --git a/algorithm/target/test-classes/DP/LongestCommonSubsequenceTest.class b/algorithm/target/test-classes/DP/LongestCommonSubsequenceTest.class
new file mode 100644
index 0000000..96c863a
Binary files /dev/null and b/algorithm/target/test-classes/DP/LongestCommonSubsequenceTest.class differ
diff --git a/algorithm/target/test-classes/DP/MinFallingPathSum2Test.class b/algorithm/target/test-classes/DP/MinFallingPathSum2Test.class
new file mode 100644
index 0000000..d7acc71
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinFallingPathSum2Test.class differ
diff --git a/algorithm/target/test-classes/DP/MinFallingPathSumIITest.class b/algorithm/target/test-classes/DP/MinFallingPathSumIITest.class
new file mode 100644
index 0000000..957e5b4
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinFallingPathSumIITest.class differ
diff --git a/algorithm/target/test-classes/DP/MinFallingPathSumTest.class b/algorithm/target/test-classes/DP/MinFallingPathSumTest.class
new file mode 100644
index 0000000..6569426
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinFallingPathSumTest.class differ
diff --git a/algorithm/target/test-classes/DP/MinPathSumTest.class b/algorithm/target/test-classes/DP/MinPathSumTest.class
new file mode 100644
index 0000000..f51e1e5
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinPathSumTest.class differ
diff --git a/algorithm/target/test-classes/DP/MinimumTriangleTotalIITest.class b/algorithm/target/test-classes/DP/MinimumTriangleTotalIITest.class
new file mode 100644
index 0000000..1c16978
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinimumTriangleTotalIITest.class differ
diff --git a/algorithm/target/test-classes/DP/MinimumTriangleTotalTest.class b/algorithm/target/test-classes/DP/MinimumTriangleTotalTest.class
new file mode 100644
index 0000000..725b099
Binary files /dev/null and b/algorithm/target/test-classes/DP/MinimumTriangleTotalTest.class differ
diff --git a/algorithm/target/test-classes/DP/PalindromeListTest.class b/algorithm/target/test-classes/DP/PalindromeListTest.class
new file mode 100644
index 0000000..269aee3
Binary files /dev/null and b/algorithm/target/test-classes/DP/PalindromeListTest.class differ
diff --git a/algorithm/target/test-classes/DP/ReverseNode2Test.class b/algorithm/target/test-classes/DP/ReverseNode2Test.class
new file mode 100644
index 0000000..917520f
Binary files /dev/null and b/algorithm/target/test-classes/DP/ReverseNode2Test.class differ
diff --git a/algorithm/target/test-classes/DP/ReverseNode3Test.class b/algorithm/target/test-classes/DP/ReverseNode3Test.class
new file mode 100644
index 0000000..0be09dd
Binary files /dev/null and b/algorithm/target/test-classes/DP/ReverseNode3Test.class differ
diff --git a/algorithm/target/test-classes/DP/ReverseNodeKGroupTest.class b/algorithm/target/test-classes/DP/ReverseNodeKGroupTest.class
new file mode 100644
index 0000000..1ccfd66
Binary files /dev/null and b/algorithm/target/test-classes/DP/ReverseNodeKGroupTest.class differ
diff --git a/algorithm/target/test-classes/DP/ReverseNodeTest.class b/algorithm/target/test-classes/DP/ReverseNodeTest.class
new file mode 100644
index 0000000..a7c6610
Binary files /dev/null and b/algorithm/target/test-classes/DP/ReverseNodeTest.class differ
diff --git a/algorithm/target/test-classes/DP/RussianDollEnvelopesTest.class b/algorithm/target/test-classes/DP/RussianDollEnvelopesTest.class
new file mode 100644
index 0000000..410a111
Binary files /dev/null and b/algorithm/target/test-classes/DP/RussianDollEnvelopesTest.class differ
diff --git a/algorithm/target/test-classes/DP/UniquePathsWithObstaclesTest.class b/algorithm/target/test-classes/DP/UniquePathsWithObstaclesTest.class
new file mode 100644
index 0000000..b331a10
Binary files /dev/null and b/algorithm/target/test-classes/DP/UniquePathsWithObstaclesTest.class differ
diff --git a/algorithm/target/test-classes/JavaStudy.class b/algorithm/target/test-classes/JavaStudy.class
new file mode 100644
index 0000000..656212a
Binary files /dev/null and b/algorithm/target/test-classes/JavaStudy.class differ
diff --git a/algorithm/target/test-classes/alibaba/DuplicateLengthTest.class b/algorithm/target/test-classes/alibaba/DuplicateLengthTest.class
new file mode 100644
index 0000000..83562ce
Binary files /dev/null and b/algorithm/target/test-classes/alibaba/DuplicateLengthTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/EatBananaTest.class b/algorithm/target/test-classes/array/binarySearch/EatBananaTest.class
new file mode 100644
index 0000000..65c4e78
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/EatBananaTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/IsSubsequenceTest.class b/algorithm/target/test-classes/array/binarySearch/IsSubsequenceTest.class
new file mode 100644
index 0000000..63e7015
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/IsSubsequenceTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/PeakArrayTest.class b/algorithm/target/test-classes/array/binarySearch/PeakArrayTest.class
new file mode 100644
index 0000000..06a433e
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/PeakArrayTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/PreimageSizeZFTest.class b/algorithm/target/test-classes/array/binarySearch/PreimageSizeZFTest.class
new file mode 100644
index 0000000..34b6563
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/PreimageSizeZFTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/SearchInsertPositionTest.class b/algorithm/target/test-classes/array/binarySearch/SearchInsertPositionTest.class
new file mode 100644
index 0000000..0d09719
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/SearchInsertPositionTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/SearchMatrixTest.class b/algorithm/target/test-classes/array/binarySearch/SearchMatrixTest.class
new file mode 100644
index 0000000..950def7
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/SearchMatrixTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/SearchPositionTest.class b/algorithm/target/test-classes/array/binarySearch/SearchPositionTest.class
new file mode 100644
index 0000000..168d166
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/SearchPositionTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/SearchRangeTest.class b/algorithm/target/test-classes/array/binarySearch/SearchRangeTest.class
new file mode 100644
index 0000000..a5540e1
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/SearchRangeTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/ShipWithinDaysTest.class b/algorithm/target/test-classes/array/binarySearch/ShipWithinDaysTest.class
new file mode 100644
index 0000000..6de5a09
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/ShipWithinDaysTest.class differ
diff --git a/algorithm/target/test-classes/array/binarySearch/TailingZerosTest.class b/algorithm/target/test-classes/array/binarySearch/TailingZerosTest.class
new file mode 100644
index 0000000..dc6793b
Binary files /dev/null and b/algorithm/target/test-classes/array/binarySearch/TailingZerosTest.class differ
diff --git a/algorithm/target/test-classes/array/other/AdvantageShuffleTest.class b/algorithm/target/test-classes/array/other/AdvantageShuffleTest.class
new file mode 100644
index 0000000..b0c2406
Binary files /dev/null and b/algorithm/target/test-classes/array/other/AdvantageShuffleTest.class differ
diff --git a/algorithm/target/test-classes/array/other/ContainerWithMostWaterTest.class b/algorithm/target/test-classes/array/other/ContainerWithMostWaterTest.class
new file mode 100644
index 0000000..8c2818d
Binary files /dev/null and b/algorithm/target/test-classes/array/other/ContainerWithMostWaterTest.class differ
diff --git a/algorithm/target/test-classes/array/other/IntervalListIntersectionsTest.class b/algorithm/target/test-classes/array/other/IntervalListIntersectionsTest.class
new file mode 100644
index 0000000..22610bd
Binary files /dev/null and b/algorithm/target/test-classes/array/other/IntervalListIntersectionsTest.class differ
diff --git a/algorithm/target/test-classes/array/other/MaxRepeatSubStringTest.class b/algorithm/target/test-classes/array/other/MaxRepeatSubStringTest.class
new file mode 100644
index 0000000..73ed227
Binary files /dev/null and b/algorithm/target/test-classes/array/other/MaxRepeatSubStringTest.class differ
diff --git a/algorithm/target/test-classes/array/other/RemoveDuplicateSortedArrayTest.class b/algorithm/target/test-classes/array/other/RemoveDuplicateSortedArrayTest.class
new file mode 100644
index 0000000..10b91da
Binary files /dev/null and b/algorithm/target/test-classes/array/other/RemoveDuplicateSortedArrayTest.class differ
diff --git a/algorithm/target/test-classes/array/other/Search2DMatrixIITest.class b/algorithm/target/test-classes/array/other/Search2DMatrixIITest.class
new file mode 100644
index 0000000..cdd555c
Binary files /dev/null and b/algorithm/target/test-classes/array/other/Search2DMatrixIITest.class differ
diff --git a/algorithm/target/test-classes/array/other/SquaresSortedArrayTest.class b/algorithm/target/test-classes/array/other/SquaresSortedArrayTest.class
new file mode 100644
index 0000000..530ea63
Binary files /dev/null and b/algorithm/target/test-classes/array/other/SquaresSortedArrayTest.class differ
diff --git a/algorithm/target/test-classes/array/other/TrappingRainWaterTest.class b/algorithm/target/test-classes/array/other/TrappingRainWaterTest.class
new file mode 100644
index 0000000..81de725
Binary files /dev/null and b/algorithm/target/test-classes/array/other/TrappingRainWaterTest.class differ
diff --git a/algorithm/target/test-classes/array/other/TwoSumLessThanKTest.class b/algorithm/target/test-classes/array/other/TwoSumLessThanKTest.class
new file mode 100644
index 0000000..e34a782
Binary files /dev/null and b/algorithm/target/test-classes/array/other/TwoSumLessThanKTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/FindAnagramsTest.class b/algorithm/target/test-classes/array/slideWIndow/FindAnagramsTest.class
new file mode 100644
index 0000000..4d29c52
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/FindAnagramsTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/LengthOfLongestSubstringTest.class b/algorithm/target/test-classes/array/slideWIndow/LengthOfLongestSubstringTest.class
new file mode 100644
index 0000000..cfd4e5f
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/LengthOfLongestSubstringTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/MinWindowSubstringTest.class b/algorithm/target/test-classes/array/slideWIndow/MinWindowSubstringTest.class
new file mode 100644
index 0000000..30dc226
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/MinWindowSubstringTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/MinimumWindowTest.class b/algorithm/target/test-classes/array/slideWIndow/MinimumWindowTest.class
new file mode 100644
index 0000000..49b55af
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/MinimumWindowTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/PermutationTest.class b/algorithm/target/test-classes/array/slideWIndow/PermutationTest.class
new file mode 100644
index 0000000..06f2667
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/PermutationTest.class differ
diff --git a/algorithm/target/test-classes/array/slideWIndow/SlidingWindowMaximumTest.class b/algorithm/target/test-classes/array/slideWIndow/SlidingWindowMaximumTest.class
new file mode 100644
index 0000000..a2a98b8
Binary files /dev/null and b/algorithm/target/test-classes/array/slideWIndow/SlidingWindowMaximumTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/CombinationSumTest.class b/algorithm/target/test-classes/backTrack/CombinationSumTest.class
new file mode 100644
index 0000000..58b2525
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/CombinationSumTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/CombinationsTest.class b/algorithm/target/test-classes/backTrack/CombinationsTest.class
new file mode 100644
index 0000000..d717843
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/CombinationsTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/GenerateParenthesesTest.class b/algorithm/target/test-classes/backTrack/GenerateParenthesesTest.class
new file mode 100644
index 0000000..2634c55
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/GenerateParenthesesTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/MaximumDepthBinaryTreeTest.class b/algorithm/target/test-classes/backTrack/MaximumDepthBinaryTreeTest.class
new file mode 100644
index 0000000..3dcb891
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/MaximumDepthBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/NQueuesTest.class b/algorithm/target/test-classes/backTrack/NQueuesTest.class
new file mode 100644
index 0000000..f649cd7
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/NQueuesTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/PartitionKEqualSumSubsetsTest.class b/algorithm/target/test-classes/backTrack/PartitionKEqualSumSubsetsTest.class
new file mode 100644
index 0000000..47a5a03
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/PartitionKEqualSumSubsetsTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/PermutationsTest.class b/algorithm/target/test-classes/backTrack/PermutationsTest.class
new file mode 100644
index 0000000..a73d75d
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/PermutationsTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/SubsetsTest.class b/algorithm/target/test-classes/backTrack/SubsetsTest.class
new file mode 100644
index 0000000..77f81d7
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/SubsetsTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/SudokuSolverTest.class b/algorithm/target/test-classes/backTrack/SudokuSolverTest.class
new file mode 100644
index 0000000..85a6119
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/SudokuSolverTest.class differ
diff --git a/algorithm/target/test-classes/backTrack/TargetSum2Test.class b/algorithm/target/test-classes/backTrack/TargetSum2Test.class
new file mode 100644
index 0000000..d49ecfd
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/TargetSum2Test.class differ
diff --git a/algorithm/target/test-classes/backTrack/TargetSumTest.class b/algorithm/target/test-classes/backTrack/TargetSumTest.class
new file mode 100644
index 0000000..d0187e4
Binary files /dev/null and b/algorithm/target/test-classes/backTrack/TargetSumTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/KthLargestDataTest.class b/algorithm/target/test-classes/binaryHeap/KthLargestDataTest.class
new file mode 100644
index 0000000..d293569
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/KthLargestDataTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/KthLargestElementTest.class b/algorithm/target/test-classes/binaryHeap/KthLargestElementTest.class
new file mode 100644
index 0000000..6ae5401
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/KthLargestElementTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/LRUCacheTest.class b/algorithm/target/test-classes/binaryHeap/LRUCacheTest.class
new file mode 100644
index 0000000..a11a24d
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/LRUCacheTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/MaxFrequencyTest.class b/algorithm/target/test-classes/binaryHeap/MaxFrequencyTest.class
new file mode 100644
index 0000000..50f5553
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/MaxFrequencyTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/MedianDataTest.class b/algorithm/target/test-classes/binaryHeap/MedianDataTest.class
new file mode 100644
index 0000000..ffb57fd
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/MedianDataTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/MergeSortedListsTest.class b/algorithm/target/test-classes/binaryHeap/MergeSortedListsTest.class
new file mode 100644
index 0000000..9de910e
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/MergeSortedListsTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/MinStackTest.class b/algorithm/target/test-classes/binaryHeap/MinStackTest.class
new file mode 100644
index 0000000..39b6842
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/MinStackTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/SeatReserveTest.class b/algorithm/target/test-classes/binaryHeap/SeatReserveTest.class
new file mode 100644
index 0000000..8782085
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/SeatReserveTest.class differ
diff --git a/algorithm/target/test-classes/binaryHeap/SingleThreadCPUTest.class b/algorithm/target/test-classes/binaryHeap/SingleThreadCPUTest.class
new file mode 100644
index 0000000..6916466
Binary files /dev/null and b/algorithm/target/test-classes/binaryHeap/SingleThreadCPUTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/BinaryTreeLevelOrderTraversalTest.class b/algorithm/target/test-classes/binaryTree/BinaryTreeLevelOrderTraversalTest.class
new file mode 100644
index 0000000..5367fee
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/BinaryTreeLevelOrderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/BinaryTreePostorderTraversalTest.class b/algorithm/target/test-classes/binaryTree/BinaryTreePostorderTraversalTest.class
new file mode 100644
index 0000000..ff805b6
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/BinaryTreePostorderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.class b/algorithm/target/test-classes/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.class
new file mode 100644
index 0000000..fa3f806
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/BinaryTreeZigzagLevelOrderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/DiameterBinaryTreeTest.class b/algorithm/target/test-classes/binaryTree/DiameterBinaryTreeTest.class
new file mode 100644
index 0000000..ff6788f
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/DiameterBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/FlattenBinaryTreeToLinkedListTest.class b/algorithm/target/test-classes/binaryTree/FlattenBinaryTreeToLinkedListTest.class
new file mode 100644
index 0000000..6ec8576
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/FlattenBinaryTreeToLinkedListTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/InorderTraversalTest.class b/algorithm/target/test-classes/binaryTree/InorderTraversalTest.class
new file mode 100644
index 0000000..6ad09f3
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/InorderTraversalTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/IntegerTest.class b/algorithm/target/test-classes/binaryTree/IntegerTest.class
new file mode 100644
index 0000000..6b32b74
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/IntegerTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/InvertBinaryTreeTest.class b/algorithm/target/test-classes/binaryTree/InvertBinaryTreeTest.class
new file mode 100644
index 0000000..951f088
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/InvertBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/MaximumDepthNTreeTest.class b/algorithm/target/test-classes/binaryTree/MaximumDepthNTreeTest.class
new file mode 100644
index 0000000..e826e02
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/MaximumDepthNTreeTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/MinimumDepthBinaryTreeTest.class b/algorithm/target/test-classes/binaryTree/MinimumDepthBinaryTreeTest.class
new file mode 100644
index 0000000..a19c08a
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/MinimumDepthBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/binaryTree/SameTree2Test.class b/algorithm/target/test-classes/binaryTree/SameTree2Test.class
new file mode 100644
index 0000000..409e7ec
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/SameTree2Test.class differ
diff --git a/algorithm/target/test-classes/binaryTree/SerializeAndDeserializeBinaryTreeTest.class b/algorithm/target/test-classes/binaryTree/SerializeAndDeserializeBinaryTreeTest.class
new file mode 100644
index 0000000..d9447f7
Binary files /dev/null and b/algorithm/target/test-classes/binaryTree/SerializeAndDeserializeBinaryTreeTest.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/FlattenNestedListIterator.class b/algorithm/target/test-classes/dataStructureDesign/FlattenNestedListIterator.class
new file mode 100644
index 0000000..d382b90
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/FlattenNestedListIterator.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/InsertDeleteGetRandomTest.class b/algorithm/target/test-classes/dataStructureDesign/InsertDeleteGetRandomTest.class
new file mode 100644
index 0000000..5b38992
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/InsertDeleteGetRandomTest.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/LFUCacheTest.class b/algorithm/target/test-classes/dataStructureDesign/LFUCacheTest.class
new file mode 100644
index 0000000..72fd22c
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/LFUCacheTest.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/LRUCache2Test.class b/algorithm/target/test-classes/dataStructureDesign/LRUCache2Test.class
new file mode 100644
index 0000000..604f9dd
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/LRUCache2Test.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/LRUCacheTest.class b/algorithm/target/test-classes/dataStructureDesign/LRUCacheTest.class
new file mode 100644
index 0000000..c8a0a3c
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/LRUCacheTest.class differ
diff --git a/algorithm/target/test-classes/dataStructureDesign/NestedInteger.class b/algorithm/target/test-classes/dataStructureDesign/NestedInteger.class
new file mode 100644
index 0000000..c7d7520
Binary files /dev/null and b/algorithm/target/test-classes/dataStructureDesign/NestedInteger.class differ
diff --git a/algorithm/target/test-classes/differenceArray/CarPoolingTest.class b/algorithm/target/test-classes/differenceArray/CarPoolingTest.class
new file mode 100644
index 0000000..7266394
Binary files /dev/null and b/algorithm/target/test-classes/differenceArray/CarPoolingTest.class differ
diff --git a/algorithm/target/test-classes/differenceArray/FlightBookingTest.class b/algorithm/target/test-classes/differenceArray/FlightBookingTest.class
new file mode 100644
index 0000000..4802929
Binary files /dev/null and b/algorithm/target/test-classes/differenceArray/FlightBookingTest.class differ
diff --git a/algorithm/target/test-classes/differenceArray/RangeAddTest.class b/algorithm/target/test-classes/differenceArray/RangeAddTest.class
new file mode 100644
index 0000000..49d9d5f
Binary files /dev/null and b/algorithm/target/test-classes/differenceArray/RangeAddTest.class differ
diff --git a/algorithm/target/test-classes/graphTherory/AllPathListTest.class b/algorithm/target/test-classes/graphTherory/AllPathListTest.class
new file mode 100644
index 0000000..0ec87e4
Binary files /dev/null and b/algorithm/target/test-classes/graphTherory/AllPathListTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbers2Test.class b/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbers2Test.class
new file mode 100644
index 0000000..05f1c46
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbers2Test.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbersTest.class b/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbersTest.class
new file mode 100644
index 0000000..ebe4842
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/AddTwoNumbersTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/DeleteNthNodeTest.class b/algorithm/target/test-classes/linkedList/doublePointer/DeleteNthNodeTest.class
new file mode 100644
index 0000000..5b7391d
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/DeleteNthNodeTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleIITest.class b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleIITest.class
new file mode 100644
index 0000000..8922f6f
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleIITest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleTest.class b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleTest.class
new file mode 100644
index 0000000..c457b2e
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListCycleTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/LinkedListIntersectTest.class b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListIntersectTest.class
new file mode 100644
index 0000000..8e5f387
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/LinkedListIntersectTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/MergeKSortedListTest.class b/algorithm/target/test-classes/linkedList/doublePointer/MergeKSortedListTest.class
new file mode 100644
index 0000000..263103b
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/MergeKSortedListTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/MergeSortedListTest.class b/algorithm/target/test-classes/linkedList/doublePointer/MergeSortedListTest.class
new file mode 100644
index 0000000..e8e24ea
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/MergeSortedListTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/MiddleNodeTest.class b/algorithm/target/test-classes/linkedList/doublePointer/MiddleNodeTest.class
new file mode 100644
index 0000000..95ca937
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/MiddleNodeTest.class differ
diff --git a/algorithm/target/test-classes/linkedList/doublePointer/RemoveDuplicateTest.class b/algorithm/target/test-classes/linkedList/doublePointer/RemoveDuplicateTest.class
new file mode 100644
index 0000000..d5a39c9
Binary files /dev/null and b/algorithm/target/test-classes/linkedList/doublePointer/RemoveDuplicateTest.class differ
diff --git a/algorithm/target/test-classes/nSum/NSumTest.class b/algorithm/target/test-classes/nSum/NSumTest.class
new file mode 100644
index 0000000..ebacf3a
Binary files /dev/null and b/algorithm/target/test-classes/nSum/NSumTest.class differ
diff --git a/algorithm/target/test-classes/nSum/ThreeSumTest.class b/algorithm/target/test-classes/nSum/ThreeSumTest.class
new file mode 100644
index 0000000..27fdd9e
Binary files /dev/null and b/algorithm/target/test-classes/nSum/ThreeSumTest.class differ
diff --git a/algorithm/target/test-classes/nSum/TwoSumTest.class b/algorithm/target/test-classes/nSum/TwoSumTest.class
new file mode 100644
index 0000000..b61a7b6
Binary files /dev/null and b/algorithm/target/test-classes/nSum/TwoSumTest.class differ
diff --git a/algorithm/target/test-classes/offer/DivideTest.class b/algorithm/target/test-classes/offer/DivideTest.class
new file mode 100644
index 0000000..841ecd9
Binary files /dev/null and b/algorithm/target/test-classes/offer/DivideTest.class differ
diff --git a/algorithm/target/test-classes/other/IsIsomorphicTest.class b/algorithm/target/test-classes/other/IsIsomorphicTest.class
new file mode 100644
index 0000000..a1e5f41
Binary files /dev/null and b/algorithm/target/test-classes/other/IsIsomorphicTest.class differ
diff --git a/algorithm/target/test-classes/prefixSum/MatrixSumTest.class b/algorithm/target/test-classes/prefixSum/MatrixSumTest.class
new file mode 100644
index 0000000..a62dbc4
Binary files /dev/null and b/algorithm/target/test-classes/prefixSum/MatrixSumTest.class differ
diff --git a/algorithm/target/test-classes/prefixSum/NumArrayTest.class b/algorithm/target/test-classes/prefixSum/NumArrayTest.class
new file mode 100644
index 0000000..cd67a6f
Binary files /dev/null and b/algorithm/target/test-classes/prefixSum/NumArrayTest.class differ
diff --git a/algorithm/target/test-classes/prefixSum/NumMatrixTest.class b/algorithm/target/test-classes/prefixSum/NumMatrixTest.class
new file mode 100644
index 0000000..1744a68
Binary files /dev/null and b/algorithm/target/test-classes/prefixSum/NumMatrixTest.class differ
diff --git a/algorithm/target/test-classes/prefixSum/ProductOfNumbersTest.class b/algorithm/target/test-classes/prefixSum/ProductOfNumbersTest.class
new file mode 100644
index 0000000..2d540da
Binary files /dev/null and b/algorithm/target/test-classes/prefixSum/ProductOfNumbersTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/EvalRPNTest.class b/algorithm/target/test-classes/stack_queue/EvalRPNTest.class
new file mode 100644
index 0000000..535ddce
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/EvalRPNTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/ImplementQueueUsingStacksTest.class b/algorithm/target/test-classes/stack_queue/ImplementQueueUsingStacksTest.class
new file mode 100644
index 0000000..bbdb49b
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/ImplementQueueUsingStacksTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/ImplementStackUsingQueuesTest.class b/algorithm/target/test-classes/stack_queue/ImplementStackUsingQueuesTest.class
new file mode 100644
index 0000000..fafe954
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/ImplementStackUsingQueuesTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/LongestValidParenthesesTest.class b/algorithm/target/test-classes/stack_queue/LongestValidParenthesesTest.class
new file mode 100644
index 0000000..c26b722
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/LongestValidParenthesesTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/MinAddMakeValidTest.class b/algorithm/target/test-classes/stack_queue/MinAddMakeValidTest.class
new file mode 100644
index 0000000..e419e45
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/MinAddMakeValidTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/MinStackTest.class b/algorithm/target/test-classes/stack_queue/MinStackTest.class
new file mode 100644
index 0000000..15a6efc
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/MinStackTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/MinimumInsertionsToBalanceParenthesesTest.class b/algorithm/target/test-classes/stack_queue/MinimumInsertionsToBalanceParenthesesTest.class
new file mode 100644
index 0000000..d1add86
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/MinimumInsertionsToBalanceParenthesesTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/QueueTest$QueueNode.class b/algorithm/target/test-classes/stack_queue/QueueTest$QueueNode.class
new file mode 100644
index 0000000..3ab27c8
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/QueueTest$QueueNode.class differ
diff --git a/algorithm/target/test-classes/stack_queue/QueueTest.class b/algorithm/target/test-classes/stack_queue/QueueTest.class
new file mode 100644
index 0000000..1c98439
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/QueueTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/SimplifyPathTest.class b/algorithm/target/test-classes/stack_queue/SimplifyPathTest.class
new file mode 100644
index 0000000..2df732d
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/SimplifyPathTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/SlidingWindowMaxTest.class b/algorithm/target/test-classes/stack_queue/SlidingWindowMaxTest.class
new file mode 100644
index 0000000..8d17463
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/SlidingWindowMaxTest.class differ
diff --git a/algorithm/target/test-classes/stack_queue/ValidParenthesesTest.class b/algorithm/target/test-classes/stack_queue/ValidParenthesesTest.class
new file mode 100644
index 0000000..3faed6f
Binary files /dev/null and b/algorithm/target/test-classes/stack_queue/ValidParenthesesTest.class differ
diff --git a/leetcode/target/classes/AreNumbersAscending.class b/leetcode/target/classes/AreNumbersAscending.class
new file mode 100644
index 0000000..e9892d6
Binary files /dev/null and b/leetcode/target/classes/AreNumbersAscending.class differ
diff --git a/leetcode/target/classes/ArrayStringsAreEqual.class b/leetcode/target/classes/ArrayStringsAreEqual.class
new file mode 100644
index 0000000..3645620
Binary files /dev/null and b/leetcode/target/classes/ArrayStringsAreEqual.class differ
diff --git a/leetcode/target/classes/ArrayStringsAreEqualRedoI.class b/leetcode/target/classes/ArrayStringsAreEqualRedoI.class
new file mode 100644
index 0000000..dfcc722
Binary files /dev/null and b/leetcode/target/classes/ArrayStringsAreEqualRedoI.class differ
diff --git a/leetcode/target/classes/BuildTree.class b/leetcode/target/classes/BuildTree.class
new file mode 100644
index 0000000..ae7caa1
Binary files /dev/null and b/leetcode/target/classes/BuildTree.class differ
diff --git a/leetcode/target/classes/CanJump.class b/leetcode/target/classes/CanJump.class
new file mode 100644
index 0000000..84d5d68
Binary files /dev/null and b/leetcode/target/classes/CanJump.class differ
diff --git a/leetcode/target/classes/CheckInclusion.class b/leetcode/target/classes/CheckInclusion.class
new file mode 100644
index 0000000..e9158da
Binary files /dev/null and b/leetcode/target/classes/CheckInclusion.class differ
diff --git a/leetcode/target/classes/CheckOnesSegment.class b/leetcode/target/classes/CheckOnesSegment.class
new file mode 100644
index 0000000..437f7fb
Binary files /dev/null and b/leetcode/target/classes/CheckOnesSegment.class differ
diff --git a/leetcode/target/classes/CombinationSum.class b/leetcode/target/classes/CombinationSum.class
new file mode 100644
index 0000000..b10873c
Binary files /dev/null and b/leetcode/target/classes/CombinationSum.class differ
diff --git a/leetcode/target/classes/CombinationSum2.class b/leetcode/target/classes/CombinationSum2.class
new file mode 100644
index 0000000..27c51c0
Binary files /dev/null and b/leetcode/target/classes/CombinationSum2.class differ
diff --git a/leetcode/target/classes/Combine.class b/leetcode/target/classes/Combine.class
new file mode 100644
index 0000000..ab1c330
Binary files /dev/null and b/leetcode/target/classes/Combine.class differ
diff --git a/leetcode/target/classes/CommonChars.class b/leetcode/target/classes/CommonChars.class
new file mode 100644
index 0000000..b6955a7
Binary files /dev/null and b/leetcode/target/classes/CommonChars.class differ
diff --git a/leetcode/target/classes/CountPrimes.class b/leetcode/target/classes/CountPrimes.class
new file mode 100644
index 0000000..0ff3f30
Binary files /dev/null and b/leetcode/target/classes/CountPrimes.class differ
diff --git a/leetcode/target/classes/CuttingRope.class b/leetcode/target/classes/CuttingRope.class
new file mode 100644
index 0000000..9ecb5b3
Binary files /dev/null and b/leetcode/target/classes/CuttingRope.class differ
diff --git a/leetcode/target/classes/CuttingRopeII.class b/leetcode/target/classes/CuttingRopeII.class
new file mode 100644
index 0000000..bf6f898
Binary files /dev/null and b/leetcode/target/classes/CuttingRopeII.class differ
diff --git a/leetcode/target/classes/DecodeString.class b/leetcode/target/classes/DecodeString.class
new file mode 100644
index 0000000..1f71d5c
Binary files /dev/null and b/leetcode/target/classes/DecodeString.class differ
diff --git a/leetcode/target/classes/DeleteAndEarn.class b/leetcode/target/classes/DeleteAndEarn.class
new file mode 100644
index 0000000..180e61b
Binary files /dev/null and b/leetcode/target/classes/DeleteAndEarn.class differ
diff --git a/leetcode/target/classes/DeleteDuplicates.class b/leetcode/target/classes/DeleteDuplicates.class
new file mode 100644
index 0000000..c61ebe1
Binary files /dev/null and b/leetcode/target/classes/DeleteDuplicates.class differ
diff --git a/leetcode/target/classes/DeleteDuplicatesII.class b/leetcode/target/classes/DeleteDuplicatesII.class
new file mode 100644
index 0000000..eb170c5
Binary files /dev/null and b/leetcode/target/classes/DeleteDuplicatesII.class differ
diff --git a/leetcode/target/classes/Divide.class b/leetcode/target/classes/Divide.class
new file mode 100644
index 0000000..781caa2
Binary files /dev/null and b/leetcode/target/classes/Divide.class differ
diff --git a/leetcode/target/classes/Exist.class b/leetcode/target/classes/Exist.class
new file mode 100644
index 0000000..e7d06f3
Binary files /dev/null and b/leetcode/target/classes/Exist.class differ
diff --git a/leetcode/target/classes/Expand.class b/leetcode/target/classes/Expand.class
new file mode 100644
index 0000000..fc0398e
Binary files /dev/null and b/leetcode/target/classes/Expand.class differ
diff --git a/leetcode/target/classes/FindDuplicate.class b/leetcode/target/classes/FindDuplicate.class
new file mode 100644
index 0000000..053684f
Binary files /dev/null and b/leetcode/target/classes/FindDuplicate.class differ
diff --git a/leetcode/target/classes/FindMedianSortedArrays.class b/leetcode/target/classes/FindMedianSortedArrays.class
new file mode 100644
index 0000000..382974f
Binary files /dev/null and b/leetcode/target/classes/FindMedianSortedArrays.class differ
diff --git a/leetcode/target/classes/FindMedianSortedArraysII.class b/leetcode/target/classes/FindMedianSortedArraysII.class
new file mode 100644
index 0000000..713be8b
Binary files /dev/null and b/leetcode/target/classes/FindMedianSortedArraysII.class differ
diff --git a/leetcode/target/classes/FindMedianSortedArraysIII.class b/leetcode/target/classes/FindMedianSortedArraysIII.class
new file mode 100644
index 0000000..aea0510
Binary files /dev/null and b/leetcode/target/classes/FindMedianSortedArraysIII.class differ
diff --git a/leetcode/target/classes/FindMin.class b/leetcode/target/classes/FindMin.class
new file mode 100644
index 0000000..7b3f087
Binary files /dev/null and b/leetcode/target/classes/FindMin.class differ
diff --git a/leetcode/target/classes/FindPeakElement.class b/leetcode/target/classes/FindPeakElement.class
new file mode 100644
index 0000000..dd08d52
Binary files /dev/null and b/leetcode/target/classes/FindPeakElement.class differ
diff --git a/leetcode/target/classes/FirstMissingPositive.class b/leetcode/target/classes/FirstMissingPositive.class
new file mode 100644
index 0000000..64609d5
Binary files /dev/null and b/leetcode/target/classes/FirstMissingPositive.class differ
diff --git a/leetcode/target/classes/FourSum.class b/leetcode/target/classes/FourSum.class
new file mode 100644
index 0000000..8804c67
Binary files /dev/null and b/leetcode/target/classes/FourSum.class differ
diff --git a/leetcode/target/classes/FullJustify.class b/leetcode/target/classes/FullJustify.class
new file mode 100644
index 0000000..fe7e0b3
Binary files /dev/null and b/leetcode/target/classes/FullJustify.class differ
diff --git a/leetcode/target/classes/GenerateParenthesis.class b/leetcode/target/classes/GenerateParenthesis.class
new file mode 100644
index 0000000..3de9e49
Binary files /dev/null and b/leetcode/target/classes/GenerateParenthesis.class differ
diff --git a/leetcode/target/classes/GroupAnagrams.class b/leetcode/target/classes/GroupAnagrams.class
new file mode 100644
index 0000000..436d171
Binary files /dev/null and b/leetcode/target/classes/GroupAnagrams.class differ
diff --git a/leetcode/target/classes/HIndexII.class b/leetcode/target/classes/HIndexII.class
new file mode 100644
index 0000000..239a991
Binary files /dev/null and b/leetcode/target/classes/HIndexII.class differ
diff --git a/leetcode/target/classes/HammingWeight.class b/leetcode/target/classes/HammingWeight.class
new file mode 100644
index 0000000..147bd60
Binary files /dev/null and b/leetcode/target/classes/HammingWeight.class differ
diff --git a/leetcode/target/classes/InsertInterval.class b/leetcode/target/classes/InsertInterval.class
new file mode 100644
index 0000000..1f0f2c5
Binary files /dev/null and b/leetcode/target/classes/InsertInterval.class differ
diff --git a/leetcode/target/classes/IntToRoman.class b/leetcode/target/classes/IntToRoman.class
new file mode 100644
index 0000000..5b652ca
Binary files /dev/null and b/leetcode/target/classes/IntToRoman.class differ
diff --git a/leetcode/target/classes/IntegerReverse.class b/leetcode/target/classes/IntegerReverse.class
new file mode 100644
index 0000000..432b77c
Binary files /dev/null and b/leetcode/target/classes/IntegerReverse.class differ
diff --git a/leetcode/target/classes/IsInterleave.class b/leetcode/target/classes/IsInterleave.class
new file mode 100644
index 0000000..243fe1d
Binary files /dev/null and b/leetcode/target/classes/IsInterleave.class differ
diff --git a/leetcode/target/classes/IsMatch.class b/leetcode/target/classes/IsMatch.class
new file mode 100644
index 0000000..2b4de3e
Binary files /dev/null and b/leetcode/target/classes/IsMatch.class differ
diff --git a/leetcode/target/classes/IsNumber$1.class b/leetcode/target/classes/IsNumber$1.class
new file mode 100644
index 0000000..91cb29d
Binary files /dev/null and b/leetcode/target/classes/IsNumber$1.class differ
diff --git a/leetcode/target/classes/IsNumber$2.class b/leetcode/target/classes/IsNumber$2.class
new file mode 100644
index 0000000..3567223
Binary files /dev/null and b/leetcode/target/classes/IsNumber$2.class differ
diff --git a/leetcode/target/classes/IsNumber$3.class b/leetcode/target/classes/IsNumber$3.class
new file mode 100644
index 0000000..7850072
Binary files /dev/null and b/leetcode/target/classes/IsNumber$3.class differ
diff --git a/leetcode/target/classes/IsNumber$4.class b/leetcode/target/classes/IsNumber$4.class
new file mode 100644
index 0000000..e21b8ea
Binary files /dev/null and b/leetcode/target/classes/IsNumber$4.class differ
diff --git a/leetcode/target/classes/IsNumber$5.class b/leetcode/target/classes/IsNumber$5.class
new file mode 100644
index 0000000..aa6a62c
Binary files /dev/null and b/leetcode/target/classes/IsNumber$5.class differ
diff --git a/leetcode/target/classes/IsNumber$6.class b/leetcode/target/classes/IsNumber$6.class
new file mode 100644
index 0000000..99e756e
Binary files /dev/null and b/leetcode/target/classes/IsNumber$6.class differ
diff --git a/leetcode/target/classes/IsNumber$7.class b/leetcode/target/classes/IsNumber$7.class
new file mode 100644
index 0000000..f69dacc
Binary files /dev/null and b/leetcode/target/classes/IsNumber$7.class differ
diff --git a/leetcode/target/classes/IsNumber$8.class b/leetcode/target/classes/IsNumber$8.class
new file mode 100644
index 0000000..14564d7
Binary files /dev/null and b/leetcode/target/classes/IsNumber$8.class differ
diff --git a/leetcode/target/classes/IsNumber$9.class b/leetcode/target/classes/IsNumber$9.class
new file mode 100644
index 0000000..c3ff52e
Binary files /dev/null and b/leetcode/target/classes/IsNumber$9.class differ
diff --git a/leetcode/target/classes/IsNumber.class b/leetcode/target/classes/IsNumber.class
new file mode 100644
index 0000000..a4eb916
Binary files /dev/null and b/leetcode/target/classes/IsNumber.class differ
diff --git a/leetcode/target/classes/IsSubstructure.class b/leetcode/target/classes/IsSubstructure.class
new file mode 100644
index 0000000..0f53649
Binary files /dev/null and b/leetcode/target/classes/IsSubstructure.class differ
diff --git a/leetcode/target/classes/Jump.class b/leetcode/target/classes/Jump.class
new file mode 100644
index 0000000..549d0c3
Binary files /dev/null and b/leetcode/target/classes/Jump.class differ
diff --git a/leetcode/target/classes/LengthOfLIS.class b/leetcode/target/classes/LengthOfLIS.class
new file mode 100644
index 0000000..c8f8fa1
Binary files /dev/null and b/leetcode/target/classes/LengthOfLIS.class differ
diff --git a/leetcode/target/classes/LengthOfLastWord.class b/leetcode/target/classes/LengthOfLastWord.class
new file mode 100644
index 0000000..8b1bd2c
Binary files /dev/null and b/leetcode/target/classes/LengthOfLastWord.class differ
diff --git a/leetcode/target/classes/LetterCasePermutation.class b/leetcode/target/classes/LetterCasePermutation.class
new file mode 100644
index 0000000..ce44716
Binary files /dev/null and b/leetcode/target/classes/LetterCasePermutation.class differ
diff --git a/leetcode/target/classes/LetterCombinations.class b/leetcode/target/classes/LetterCombinations.class
new file mode 100644
index 0000000..57f188b
Binary files /dev/null and b/leetcode/target/classes/LetterCombinations.class differ
diff --git a/leetcode/target/classes/ListNode.class b/leetcode/target/classes/ListNode.class
new file mode 100644
index 0000000..016c254
Binary files /dev/null and b/leetcode/target/classes/ListNode.class differ
diff --git a/leetcode/target/classes/LongestPalindrome.class b/leetcode/target/classes/LongestPalindrome.class
new file mode 100644
index 0000000..d3b32a1
Binary files /dev/null and b/leetcode/target/classes/LongestPalindrome.class differ
diff --git a/leetcode/target/classes/LongestValidParentheses.class b/leetcode/target/classes/LongestValidParentheses.class
new file mode 100644
index 0000000..535da72
Binary files /dev/null and b/leetcode/target/classes/LongestValidParentheses.class differ
diff --git a/leetcode/target/classes/LongestValidParenthesesII.class b/leetcode/target/classes/LongestValidParenthesesII.class
new file mode 100644
index 0000000..2eba828
Binary files /dev/null and b/leetcode/target/classes/LongestValidParenthesesII.class differ
diff --git a/leetcode/target/classes/META-INF/leetcode.kotlin_module b/leetcode/target/classes/META-INF/leetcode.kotlin_module
new file mode 100644
index 0000000..2983af7
Binary files /dev/null and b/leetcode/target/classes/META-INF/leetcode.kotlin_module differ
diff --git a/leetcode/target/classes/MaxArea.class b/leetcode/target/classes/MaxArea.class
new file mode 100644
index 0000000..dbb2e62
Binary files /dev/null and b/leetcode/target/classes/MaxArea.class differ
diff --git a/leetcode/target/classes/MaxPoints.class b/leetcode/target/classes/MaxPoints.class
new file mode 100644
index 0000000..8379f20
Binary files /dev/null and b/leetcode/target/classes/MaxPoints.class differ
diff --git a/leetcode/target/classes/MaxSubArray.class b/leetcode/target/classes/MaxSubArray.class
new file mode 100644
index 0000000..35cdb43
Binary files /dev/null and b/leetcode/target/classes/MaxSubArray.class differ
diff --git a/leetcode/target/classes/MaxSubArrayII.class b/leetcode/target/classes/MaxSubArrayII.class
new file mode 100644
index 0000000..686f3f1
Binary files /dev/null and b/leetcode/target/classes/MaxSubArrayII.class differ
diff --git a/leetcode/target/classes/MaxSubarraySumCircular.class b/leetcode/target/classes/MaxSubarraySumCircular.class
new file mode 100644
index 0000000..ea63357
Binary files /dev/null and b/leetcode/target/classes/MaxSubarraySumCircular.class differ
diff --git a/leetcode/target/classes/MaxSubarraySumCircularII.class b/leetcode/target/classes/MaxSubarraySumCircularII.class
new file mode 100644
index 0000000..67f1744
Binary files /dev/null and b/leetcode/target/classes/MaxSubarraySumCircularII.class differ
diff --git a/leetcode/target/classes/MergeIntervals.class b/leetcode/target/classes/MergeIntervals.class
new file mode 100644
index 0000000..c270c81
Binary files /dev/null and b/leetcode/target/classes/MergeIntervals.class differ
diff --git a/leetcode/target/classes/MergeIntervalsII.class b/leetcode/target/classes/MergeIntervalsII.class
new file mode 100644
index 0000000..04b2b91
Binary files /dev/null and b/leetcode/target/classes/MergeIntervalsII.class differ
diff --git a/leetcode/target/classes/MergeKLists.class b/leetcode/target/classes/MergeKLists.class
new file mode 100644
index 0000000..c309ef6
Binary files /dev/null and b/leetcode/target/classes/MergeKLists.class differ
diff --git a/leetcode/target/classes/MergeTwoLists.class b/leetcode/target/classes/MergeTwoLists.class
new file mode 100644
index 0000000..a9da155
Binary files /dev/null and b/leetcode/target/classes/MergeTwoLists.class differ
diff --git a/leetcode/target/classes/MiddleNode.class b/leetcode/target/classes/MiddleNode.class
new file mode 100644
index 0000000..73829b1
Binary files /dev/null and b/leetcode/target/classes/MiddleNode.class differ
diff --git a/leetcode/target/classes/MinArea.class b/leetcode/target/classes/MinArea.class
new file mode 100644
index 0000000..1eb83f6
Binary files /dev/null and b/leetcode/target/classes/MinArea.class differ
diff --git a/leetcode/target/classes/MinMeetingRooms.class b/leetcode/target/classes/MinMeetingRooms.class
new file mode 100644
index 0000000..f3041e4
Binary files /dev/null and b/leetcode/target/classes/MinMeetingRooms.class differ
diff --git a/leetcode/target/classes/Multiply.class b/leetcode/target/classes/Multiply.class
new file mode 100644
index 0000000..2cee3f8
Binary files /dev/null and b/leetcode/target/classes/Multiply.class differ
diff --git a/leetcode/target/classes/MyAtoi.class b/leetcode/target/classes/MyAtoi.class
new file mode 100644
index 0000000..73a1ebc
Binary files /dev/null and b/leetcode/target/classes/MyAtoi.class differ
diff --git a/leetcode/target/classes/MyPow.class b/leetcode/target/classes/MyPow.class
new file mode 100644
index 0000000..6cc8f20
Binary files /dev/null and b/leetcode/target/classes/MyPow.class differ
diff --git a/leetcode/target/classes/MySqrt.class b/leetcode/target/classes/MySqrt.class
new file mode 100644
index 0000000..5a02048
Binary files /dev/null and b/leetcode/target/classes/MySqrt.class differ
diff --git a/leetcode/target/classes/NQueens.class b/leetcode/target/classes/NQueens.class
new file mode 100644
index 0000000..e3d3611
Binary files /dev/null and b/leetcode/target/classes/NQueens.class differ
diff --git a/leetcode/target/classes/NQueens2.class b/leetcode/target/classes/NQueens2.class
new file mode 100644
index 0000000..18bdcbe
Binary files /dev/null and b/leetcode/target/classes/NQueens2.class differ
diff --git a/leetcode/target/classes/Node.class b/leetcode/target/classes/Node.class
new file mode 100644
index 0000000..efaae98
Binary files /dev/null and b/leetcode/target/classes/Node.class differ
diff --git a/leetcode/target/classes/NumMatchingSubseq.class b/leetcode/target/classes/NumMatchingSubseq.class
new file mode 100644
index 0000000..52c3a35
Binary files /dev/null and b/leetcode/target/classes/NumMatchingSubseq.class differ
diff --git a/leetcode/target/classes/OrderCycleLinkedList.class b/leetcode/target/classes/OrderCycleLinkedList.class
new file mode 100644
index 0000000..e01c649
Binary files /dev/null and b/leetcode/target/classes/OrderCycleLinkedList.class differ
diff --git a/leetcode/target/classes/Partition.class b/leetcode/target/classes/Partition.class
new file mode 100644
index 0000000..5838a19
Binary files /dev/null and b/leetcode/target/classes/Partition.class differ
diff --git a/leetcode/target/classes/ReadBinaryWatch.class b/leetcode/target/classes/ReadBinaryWatch.class
new file mode 100644
index 0000000..e63b39b
Binary files /dev/null and b/leetcode/target/classes/ReadBinaryWatch.class differ
diff --git a/leetcode/target/classes/RecordSpaces.class b/leetcode/target/classes/RecordSpaces.class
new file mode 100644
index 0000000..f6cbb9a
Binary files /dev/null and b/leetcode/target/classes/RecordSpaces.class differ
diff --git a/leetcode/target/classes/RemoveDuplicates.class b/leetcode/target/classes/RemoveDuplicates.class
new file mode 100644
index 0000000..8a73028
Binary files /dev/null and b/leetcode/target/classes/RemoveDuplicates.class differ
diff --git a/leetcode/target/classes/RemoveZeroSumSublists.class b/leetcode/target/classes/RemoveZeroSumSublists.class
new file mode 100644
index 0000000..4e3b248
Binary files /dev/null and b/leetcode/target/classes/RemoveZeroSumSublists.class differ
diff --git a/leetcode/target/classes/ReorderList.class b/leetcode/target/classes/ReorderList.class
new file mode 100644
index 0000000..981723b
Binary files /dev/null and b/leetcode/target/classes/ReorderList.class differ
diff --git a/leetcode/target/classes/ReorderListII.class b/leetcode/target/classes/ReorderListII.class
new file mode 100644
index 0000000..fe5a47a
Binary files /dev/null and b/leetcode/target/classes/ReorderListII.class differ
diff --git a/leetcode/target/classes/ReverseBits.class b/leetcode/target/classes/ReverseBits.class
new file mode 100644
index 0000000..a311d17
Binary files /dev/null and b/leetcode/target/classes/ReverseBits.class differ
diff --git a/leetcode/target/classes/ReverseLeftWords.class b/leetcode/target/classes/ReverseLeftWords.class
new file mode 100644
index 0000000..3889097
Binary files /dev/null and b/leetcode/target/classes/ReverseLeftWords.class differ
diff --git a/leetcode/target/classes/ReverseList.class b/leetcode/target/classes/ReverseList.class
new file mode 100644
index 0000000..e70a8b7
Binary files /dev/null and b/leetcode/target/classes/ReverseList.class differ
diff --git a/leetcode/target/classes/ReverseWords.class b/leetcode/target/classes/ReverseWords.class
new file mode 100644
index 0000000..7a0e2a9
Binary files /dev/null and b/leetcode/target/classes/ReverseWords.class differ
diff --git a/leetcode/target/classes/ReverseWords2.class b/leetcode/target/classes/ReverseWords2.class
new file mode 100644
index 0000000..a414006
Binary files /dev/null and b/leetcode/target/classes/ReverseWords2.class differ
diff --git a/leetcode/target/classes/Rob.class b/leetcode/target/classes/Rob.class
new file mode 100644
index 0000000..47792fb
Binary files /dev/null and b/leetcode/target/classes/Rob.class differ
diff --git a/leetcode/target/classes/Rob2.class b/leetcode/target/classes/Rob2.class
new file mode 100644
index 0000000..a64eb74
Binary files /dev/null and b/leetcode/target/classes/Rob2.class differ
diff --git a/leetcode/target/classes/Search.class b/leetcode/target/classes/Search.class
new file mode 100644
index 0000000..0c6220f
Binary files /dev/null and b/leetcode/target/classes/Search.class differ
diff --git a/leetcode/target/classes/SearchII.class b/leetcode/target/classes/SearchII.class
new file mode 100644
index 0000000..d1b2ab1
Binary files /dev/null and b/leetcode/target/classes/SearchII.class differ
diff --git a/leetcode/target/classes/SearchMatrixII.class b/leetcode/target/classes/SearchMatrixII.class
new file mode 100644
index 0000000..b6dc438
Binary files /dev/null and b/leetcode/target/classes/SearchMatrixII.class differ
diff --git a/leetcode/target/classes/SearchRange.class b/leetcode/target/classes/SearchRange.class
new file mode 100644
index 0000000..377b243
Binary files /dev/null and b/leetcode/target/classes/SearchRange.class differ
diff --git a/leetcode/target/classes/SimplifyPath.class b/leetcode/target/classes/SimplifyPath.class
new file mode 100644
index 0000000..897660d
Binary files /dev/null and b/leetcode/target/classes/SimplifyPath.class differ
diff --git a/leetcode/target/classes/SortColors.class b/leetcode/target/classes/SortColors.class
new file mode 100644
index 0000000..8aaf26f
Binary files /dev/null and b/leetcode/target/classes/SortColors.class differ
diff --git a/leetcode/target/classes/SpiralOrder.class b/leetcode/target/classes/SpiralOrder.class
new file mode 100644
index 0000000..649f2ee
Binary files /dev/null and b/leetcode/target/classes/SpiralOrder.class differ
diff --git a/leetcode/target/classes/SplitIntoFibonacci.class b/leetcode/target/classes/SplitIntoFibonacci.class
new file mode 100644
index 0000000..b83f68e
Binary files /dev/null and b/leetcode/target/classes/SplitIntoFibonacci.class differ
diff --git a/leetcode/target/classes/StrStr.class b/leetcode/target/classes/StrStr.class
new file mode 100644
index 0000000..6911f38
Binary files /dev/null and b/leetcode/target/classes/StrStr.class differ
diff --git a/leetcode/target/classes/Subsets.class b/leetcode/target/classes/Subsets.class
new file mode 100644
index 0000000..fce5ea3
Binary files /dev/null and b/leetcode/target/classes/Subsets.class differ
diff --git a/leetcode/target/classes/SubsetsWithDup.class b/leetcode/target/classes/SubsetsWithDup.class
new file mode 100644
index 0000000..d71dd0b
Binary files /dev/null and b/leetcode/target/classes/SubsetsWithDup.class differ
diff --git a/leetcode/target/classes/SwapPairs.class b/leetcode/target/classes/SwapPairs.class
new file mode 100644
index 0000000..f0ec51b
Binary files /dev/null and b/leetcode/target/classes/SwapPairs.class differ
diff --git a/leetcode/target/classes/ThreeSum.class b/leetcode/target/classes/ThreeSum.class
new file mode 100644
index 0000000..75d4dc4
Binary files /dev/null and b/leetcode/target/classes/ThreeSum.class differ
diff --git a/leetcode/target/classes/ThreeSumClosest.class b/leetcode/target/classes/ThreeSumClosest.class
new file mode 100644
index 0000000..cb8a9b3
Binary files /dev/null and b/leetcode/target/classes/ThreeSumClosest.class differ
diff --git a/leetcode/target/classes/ThreeSumSmaller.class b/leetcode/target/classes/ThreeSumSmaller.class
new file mode 100644
index 0000000..cca0e05
Binary files /dev/null and b/leetcode/target/classes/ThreeSumSmaller.class differ
diff --git a/leetcode/target/classes/Trap.class b/leetcode/target/classes/Trap.class
new file mode 100644
index 0000000..031329c
Binary files /dev/null and b/leetcode/target/classes/Trap.class differ
diff --git a/leetcode/target/classes/TreeNode.class b/leetcode/target/classes/TreeNode.class
new file mode 100644
index 0000000..b59783b
Binary files /dev/null and b/leetcode/target/classes/TreeNode.class differ
diff --git a/leetcode/target/classes/ValidateStackSequences.class b/leetcode/target/classes/ValidateStackSequences.class
new file mode 100644
index 0000000..57e0984
Binary files /dev/null and b/leetcode/target/classes/ValidateStackSequences.class differ
diff --git a/leetcode/target/classes/ZigZagConvert.class b/leetcode/target/classes/ZigZagConvert.class
new file mode 100644
index 0000000..f14d687
Binary files /dev/null and b/leetcode/target/classes/ZigZagConvert.class differ
diff --git a/leetcode/target/test-classes/AreNumbersAscendingTest.class b/leetcode/target/test-classes/AreNumbersAscendingTest.class
new file mode 100644
index 0000000..5263946
Binary files /dev/null and b/leetcode/target/test-classes/AreNumbersAscendingTest.class differ
diff --git a/leetcode/target/test-classes/ArrayStringsAreEqualRedoITest.class b/leetcode/target/test-classes/ArrayStringsAreEqualRedoITest.class
new file mode 100644
index 0000000..3f3c4c3
Binary files /dev/null and b/leetcode/target/test-classes/ArrayStringsAreEqualRedoITest.class differ
diff --git a/leetcode/target/test-classes/ArrayStringsAreEqualTest.class b/leetcode/target/test-classes/ArrayStringsAreEqualTest.class
new file mode 100644
index 0000000..df81ad2
Binary files /dev/null and b/leetcode/target/test-classes/ArrayStringsAreEqualTest.class differ
diff --git a/leetcode/target/test-classes/CanJumpTest.class b/leetcode/target/test-classes/CanJumpTest.class
new file mode 100644
index 0000000..7542a12
Binary files /dev/null and b/leetcode/target/test-classes/CanJumpTest.class differ
diff --git a/leetcode/target/test-classes/CheckInclusionTest.class b/leetcode/target/test-classes/CheckInclusionTest.class
new file mode 100644
index 0000000..4eefc08
Binary files /dev/null and b/leetcode/target/test-classes/CheckInclusionTest.class differ
diff --git a/leetcode/target/test-classes/CheckOnesSegmentTest.class b/leetcode/target/test-classes/CheckOnesSegmentTest.class
new file mode 100644
index 0000000..4eabe3e
Binary files /dev/null and b/leetcode/target/test-classes/CheckOnesSegmentTest.class differ
diff --git a/leetcode/target/test-classes/CombinationSum2Test.class b/leetcode/target/test-classes/CombinationSum2Test.class
new file mode 100644
index 0000000..b8092f4
Binary files /dev/null and b/leetcode/target/test-classes/CombinationSum2Test.class differ
diff --git a/leetcode/target/test-classes/CombinationSumTest.class b/leetcode/target/test-classes/CombinationSumTest.class
new file mode 100644
index 0000000..517cda3
Binary files /dev/null and b/leetcode/target/test-classes/CombinationSumTest.class differ
diff --git a/leetcode/target/test-classes/CombineTest.class b/leetcode/target/test-classes/CombineTest.class
new file mode 100644
index 0000000..8a33b14
Binary files /dev/null and b/leetcode/target/test-classes/CombineTest.class differ
diff --git a/leetcode/target/test-classes/CommonCharsTest.class b/leetcode/target/test-classes/CommonCharsTest.class
new file mode 100644
index 0000000..c2bf69e
Binary files /dev/null and b/leetcode/target/test-classes/CommonCharsTest.class differ
diff --git a/leetcode/target/test-classes/CountPrimesTest.class b/leetcode/target/test-classes/CountPrimesTest.class
new file mode 100644
index 0000000..8d0fe7e
Binary files /dev/null and b/leetcode/target/test-classes/CountPrimesTest.class differ
diff --git a/leetcode/target/test-classes/CuttingRopeIITest.class b/leetcode/target/test-classes/CuttingRopeIITest.class
new file mode 100644
index 0000000..98046a9
Binary files /dev/null and b/leetcode/target/test-classes/CuttingRopeIITest.class differ
diff --git a/leetcode/target/test-classes/CuttingRopeTest.class b/leetcode/target/test-classes/CuttingRopeTest.class
new file mode 100644
index 0000000..9b5ca32
Binary files /dev/null and b/leetcode/target/test-classes/CuttingRopeTest.class differ
diff --git a/leetcode/target/test-classes/DecodeStringTest.class b/leetcode/target/test-classes/DecodeStringTest.class
new file mode 100644
index 0000000..314f76a
Binary files /dev/null and b/leetcode/target/test-classes/DecodeStringTest.class differ
diff --git a/leetcode/target/test-classes/DeleteAndEarnTest.class b/leetcode/target/test-classes/DeleteAndEarnTest.class
new file mode 100644
index 0000000..7bc9784
Binary files /dev/null and b/leetcode/target/test-classes/DeleteAndEarnTest.class differ
diff --git a/leetcode/target/test-classes/DeleteDuplicatesIITest.class b/leetcode/target/test-classes/DeleteDuplicatesIITest.class
new file mode 100644
index 0000000..eeccf88
Binary files /dev/null and b/leetcode/target/test-classes/DeleteDuplicatesIITest.class differ
diff --git a/leetcode/target/test-classes/DeleteDuplicatesTest.class b/leetcode/target/test-classes/DeleteDuplicatesTest.class
new file mode 100644
index 0000000..e0582bf
Binary files /dev/null and b/leetcode/target/test-classes/DeleteDuplicatesTest.class differ
diff --git a/leetcode/target/test-classes/DivideTest.class b/leetcode/target/test-classes/DivideTest.class
new file mode 100644
index 0000000..3eee6fb
Binary files /dev/null and b/leetcode/target/test-classes/DivideTest.class differ
diff --git a/leetcode/target/test-classes/ExistTest.class b/leetcode/target/test-classes/ExistTest.class
new file mode 100644
index 0000000..28daac3
Binary files /dev/null and b/leetcode/target/test-classes/ExistTest.class differ
diff --git a/leetcode/target/test-classes/ExpandTest.class b/leetcode/target/test-classes/ExpandTest.class
new file mode 100644
index 0000000..6f4be98
Binary files /dev/null and b/leetcode/target/test-classes/ExpandTest.class differ
diff --git a/leetcode/target/test-classes/FindDuplicateTest.class b/leetcode/target/test-classes/FindDuplicateTest.class
new file mode 100644
index 0000000..8a019c2
Binary files /dev/null and b/leetcode/target/test-classes/FindDuplicateTest.class differ
diff --git a/leetcode/target/test-classes/FindMedianSortedArraysIIITest.class b/leetcode/target/test-classes/FindMedianSortedArraysIIITest.class
new file mode 100644
index 0000000..248d26d
Binary files /dev/null and b/leetcode/target/test-classes/FindMedianSortedArraysIIITest.class differ
diff --git a/leetcode/target/test-classes/FindMedianSortedArraysIITest.class b/leetcode/target/test-classes/FindMedianSortedArraysIITest.class
new file mode 100644
index 0000000..d0f6f70
Binary files /dev/null and b/leetcode/target/test-classes/FindMedianSortedArraysIITest.class differ
diff --git a/leetcode/target/test-classes/FindMedianSortedArraysTest.class b/leetcode/target/test-classes/FindMedianSortedArraysTest.class
new file mode 100644
index 0000000..90e3386
Binary files /dev/null and b/leetcode/target/test-classes/FindMedianSortedArraysTest.class differ
diff --git a/leetcode/target/test-classes/FindMinTest.class b/leetcode/target/test-classes/FindMinTest.class
new file mode 100644
index 0000000..e2c90c9
Binary files /dev/null and b/leetcode/target/test-classes/FindMinTest.class differ
diff --git a/leetcode/target/test-classes/FindPeakElementTest.class b/leetcode/target/test-classes/FindPeakElementTest.class
new file mode 100644
index 0000000..b99b24b
Binary files /dev/null and b/leetcode/target/test-classes/FindPeakElementTest.class differ
diff --git a/leetcode/target/test-classes/FirstMissingPositiveTest.class b/leetcode/target/test-classes/FirstMissingPositiveTest.class
new file mode 100644
index 0000000..42f6040
Binary files /dev/null and b/leetcode/target/test-classes/FirstMissingPositiveTest.class differ
diff --git a/leetcode/target/test-classes/FourSumTest.class b/leetcode/target/test-classes/FourSumTest.class
new file mode 100644
index 0000000..977bb3a
Binary files /dev/null and b/leetcode/target/test-classes/FourSumTest.class differ
diff --git a/leetcode/target/test-classes/FullJustifyTest.class b/leetcode/target/test-classes/FullJustifyTest.class
new file mode 100644
index 0000000..d46fcad
Binary files /dev/null and b/leetcode/target/test-classes/FullJustifyTest.class differ
diff --git a/leetcode/target/test-classes/GenerateParenthesisTest.class b/leetcode/target/test-classes/GenerateParenthesisTest.class
new file mode 100644
index 0000000..18cf45b
Binary files /dev/null and b/leetcode/target/test-classes/GenerateParenthesisTest.class differ
diff --git a/leetcode/target/test-classes/GroupAnagramsTest.class b/leetcode/target/test-classes/GroupAnagramsTest.class
new file mode 100644
index 0000000..9f1440f
Binary files /dev/null and b/leetcode/target/test-classes/GroupAnagramsTest.class differ
diff --git a/leetcode/target/test-classes/HIndexIITest.class b/leetcode/target/test-classes/HIndexIITest.class
new file mode 100644
index 0000000..ae5077c
Binary files /dev/null and b/leetcode/target/test-classes/HIndexIITest.class differ
diff --git a/leetcode/target/test-classes/HammingWeightTest.class b/leetcode/target/test-classes/HammingWeightTest.class
new file mode 100644
index 0000000..f0eb642
Binary files /dev/null and b/leetcode/target/test-classes/HammingWeightTest.class differ
diff --git a/leetcode/target/test-classes/InsertIntervalTest.class b/leetcode/target/test-classes/InsertIntervalTest.class
new file mode 100644
index 0000000..1e0caff
Binary files /dev/null and b/leetcode/target/test-classes/InsertIntervalTest.class differ
diff --git a/leetcode/target/test-classes/IntToRomanTest.class b/leetcode/target/test-classes/IntToRomanTest.class
new file mode 100644
index 0000000..0f925da
Binary files /dev/null and b/leetcode/target/test-classes/IntToRomanTest.class differ
diff --git a/leetcode/target/test-classes/IntegerReverseTest.class b/leetcode/target/test-classes/IntegerReverseTest.class
new file mode 100644
index 0000000..361b45a
Binary files /dev/null and b/leetcode/target/test-classes/IntegerReverseTest.class differ
diff --git a/leetcode/target/test-classes/IsInterleaveTest.class b/leetcode/target/test-classes/IsInterleaveTest.class
new file mode 100644
index 0000000..4b203a7
Binary files /dev/null and b/leetcode/target/test-classes/IsInterleaveTest.class differ
diff --git a/leetcode/target/test-classes/IsMatchTest.class b/leetcode/target/test-classes/IsMatchTest.class
new file mode 100644
index 0000000..12ac01a
Binary files /dev/null and b/leetcode/target/test-classes/IsMatchTest.class differ
diff --git a/leetcode/target/test-classes/IsNumberTest.class b/leetcode/target/test-classes/IsNumberTest.class
new file mode 100644
index 0000000..3dc17f8
Binary files /dev/null and b/leetcode/target/test-classes/IsNumberTest.class differ
diff --git a/leetcode/target/test-classes/IsSubstructureTest.class b/leetcode/target/test-classes/IsSubstructureTest.class
new file mode 100644
index 0000000..91ea8fd
Binary files /dev/null and b/leetcode/target/test-classes/IsSubstructureTest.class differ
diff --git a/leetcode/target/test-classes/JumpTest.class b/leetcode/target/test-classes/JumpTest.class
new file mode 100644
index 0000000..d36c696
Binary files /dev/null and b/leetcode/target/test-classes/JumpTest.class differ
diff --git a/leetcode/target/test-classes/LengthOfLastWordTest.class b/leetcode/target/test-classes/LengthOfLastWordTest.class
new file mode 100644
index 0000000..22ead75
Binary files /dev/null and b/leetcode/target/test-classes/LengthOfLastWordTest.class differ
diff --git a/leetcode/target/test-classes/LetterCasePermutationTest.class b/leetcode/target/test-classes/LetterCasePermutationTest.class
new file mode 100644
index 0000000..9079b9e
Binary files /dev/null and b/leetcode/target/test-classes/LetterCasePermutationTest.class differ
diff --git a/leetcode/target/test-classes/LetterCombinationsTest.class b/leetcode/target/test-classes/LetterCombinationsTest.class
new file mode 100644
index 0000000..247ad7e
Binary files /dev/null and b/leetcode/target/test-classes/LetterCombinationsTest.class differ
diff --git a/leetcode/target/test-classes/LongestOfLISTest.class b/leetcode/target/test-classes/LongestOfLISTest.class
new file mode 100644
index 0000000..4eeea2a
Binary files /dev/null and b/leetcode/target/test-classes/LongestOfLISTest.class differ
diff --git a/leetcode/target/test-classes/LongestPalindromeTest.class b/leetcode/target/test-classes/LongestPalindromeTest.class
new file mode 100644
index 0000000..86b9b06
Binary files /dev/null and b/leetcode/target/test-classes/LongestPalindromeTest.class differ
diff --git a/leetcode/target/test-classes/LongestValidParenthesesIITest.class b/leetcode/target/test-classes/LongestValidParenthesesIITest.class
new file mode 100644
index 0000000..f402514
Binary files /dev/null and b/leetcode/target/test-classes/LongestValidParenthesesIITest.class differ
diff --git a/leetcode/target/test-classes/LongestValidParenthesesTest.class b/leetcode/target/test-classes/LongestValidParenthesesTest.class
new file mode 100644
index 0000000..90b84f4
Binary files /dev/null and b/leetcode/target/test-classes/LongestValidParenthesesTest.class differ
diff --git a/leetcode/target/test-classes/META-INF/leetcode.kotlin_module b/leetcode/target/test-classes/META-INF/leetcode.kotlin_module
new file mode 100644
index 0000000..2983af7
Binary files /dev/null and b/leetcode/target/test-classes/META-INF/leetcode.kotlin_module differ
diff --git a/leetcode/target/test-classes/MaxAreaTest.class b/leetcode/target/test-classes/MaxAreaTest.class
new file mode 100644
index 0000000..58eae1f
Binary files /dev/null and b/leetcode/target/test-classes/MaxAreaTest.class differ
diff --git a/leetcode/target/test-classes/MaxPointsTest.class b/leetcode/target/test-classes/MaxPointsTest.class
new file mode 100644
index 0000000..772b270
Binary files /dev/null and b/leetcode/target/test-classes/MaxPointsTest.class differ
diff --git a/leetcode/target/test-classes/MaxSubArrayIITest.class b/leetcode/target/test-classes/MaxSubArrayIITest.class
new file mode 100644
index 0000000..3d70676
Binary files /dev/null and b/leetcode/target/test-classes/MaxSubArrayIITest.class differ
diff --git a/leetcode/target/test-classes/MaxSubArrayTest.class b/leetcode/target/test-classes/MaxSubArrayTest.class
new file mode 100644
index 0000000..f3782a4
Binary files /dev/null and b/leetcode/target/test-classes/MaxSubArrayTest.class differ
diff --git a/leetcode/target/test-classes/MaxSubarraySumCircularIITest.class b/leetcode/target/test-classes/MaxSubarraySumCircularIITest.class
new file mode 100644
index 0000000..a1cec09
Binary files /dev/null and b/leetcode/target/test-classes/MaxSubarraySumCircularIITest.class differ
diff --git a/leetcode/target/test-classes/MaxSubarraySumCircularTest.class b/leetcode/target/test-classes/MaxSubarraySumCircularTest.class
new file mode 100644
index 0000000..23c8ed7
Binary files /dev/null and b/leetcode/target/test-classes/MaxSubarraySumCircularTest.class differ
diff --git a/leetcode/target/test-classes/MergeIntervalsIITest.class b/leetcode/target/test-classes/MergeIntervalsIITest.class
new file mode 100644
index 0000000..417ba6c
Binary files /dev/null and b/leetcode/target/test-classes/MergeIntervalsIITest.class differ
diff --git a/leetcode/target/test-classes/MergeIntervalsTest.class b/leetcode/target/test-classes/MergeIntervalsTest.class
new file mode 100644
index 0000000..44e2b1b
Binary files /dev/null and b/leetcode/target/test-classes/MergeIntervalsTest.class differ
diff --git a/leetcode/target/test-classes/MergeKListsTest.class b/leetcode/target/test-classes/MergeKListsTest.class
new file mode 100644
index 0000000..34d2ab8
Binary files /dev/null and b/leetcode/target/test-classes/MergeKListsTest.class differ
diff --git a/leetcode/target/test-classes/MergeTwoListsTest.class b/leetcode/target/test-classes/MergeTwoListsTest.class
new file mode 100644
index 0000000..9712ac5
Binary files /dev/null and b/leetcode/target/test-classes/MergeTwoListsTest.class differ
diff --git a/leetcode/target/test-classes/MinAreaTest.class b/leetcode/target/test-classes/MinAreaTest.class
new file mode 100644
index 0000000..bb3d2eb
Binary files /dev/null and b/leetcode/target/test-classes/MinAreaTest.class differ
diff --git a/leetcode/target/test-classes/MinMeetingRoomsTest.class b/leetcode/target/test-classes/MinMeetingRoomsTest.class
new file mode 100644
index 0000000..6c2a343
Binary files /dev/null and b/leetcode/target/test-classes/MinMeetingRoomsTest.class differ
diff --git a/leetcode/target/test-classes/MultiplyTest.class b/leetcode/target/test-classes/MultiplyTest.class
new file mode 100644
index 0000000..79c9c57
Binary files /dev/null and b/leetcode/target/test-classes/MultiplyTest.class differ
diff --git a/leetcode/target/test-classes/MyAtoiTest.class b/leetcode/target/test-classes/MyAtoiTest.class
new file mode 100644
index 0000000..8cfcda0
Binary files /dev/null and b/leetcode/target/test-classes/MyAtoiTest.class differ
diff --git a/leetcode/target/test-classes/MyPowTest.class b/leetcode/target/test-classes/MyPowTest.class
new file mode 100644
index 0000000..c42ddda
Binary files /dev/null and b/leetcode/target/test-classes/MyPowTest.class differ
diff --git a/leetcode/target/test-classes/MySqrtTest.class b/leetcode/target/test-classes/MySqrtTest.class
new file mode 100644
index 0000000..0a84dde
Binary files /dev/null and b/leetcode/target/test-classes/MySqrtTest.class differ
diff --git a/leetcode/target/test-classes/NQueens2Test.class b/leetcode/target/test-classes/NQueens2Test.class
new file mode 100644
index 0000000..7e1768f
Binary files /dev/null and b/leetcode/target/test-classes/NQueens2Test.class differ
diff --git a/leetcode/target/test-classes/NQueensTest.class b/leetcode/target/test-classes/NQueensTest.class
new file mode 100644
index 0000000..b8c7882
Binary files /dev/null and b/leetcode/target/test-classes/NQueensTest.class differ
diff --git a/leetcode/target/test-classes/NumMatchingSubseqTest.class b/leetcode/target/test-classes/NumMatchingSubseqTest.class
new file mode 100644
index 0000000..631c882
Binary files /dev/null and b/leetcode/target/test-classes/NumMatchingSubseqTest.class differ
diff --git a/leetcode/target/test-classes/OrderCycleLinkedListTest.class b/leetcode/target/test-classes/OrderCycleLinkedListTest.class
new file mode 100644
index 0000000..8b546c2
Binary files /dev/null and b/leetcode/target/test-classes/OrderCycleLinkedListTest.class differ
diff --git a/leetcode/target/test-classes/PartitionTest.class b/leetcode/target/test-classes/PartitionTest.class
new file mode 100644
index 0000000..e030612
Binary files /dev/null and b/leetcode/target/test-classes/PartitionTest.class differ
diff --git a/leetcode/target/test-classes/ReadBinaryWatchTest.class b/leetcode/target/test-classes/ReadBinaryWatchTest.class
new file mode 100644
index 0000000..43727b8
Binary files /dev/null and b/leetcode/target/test-classes/ReadBinaryWatchTest.class differ
diff --git a/leetcode/target/test-classes/RecordSpacesTest.class b/leetcode/target/test-classes/RecordSpacesTest.class
new file mode 100644
index 0000000..b26580c
Binary files /dev/null and b/leetcode/target/test-classes/RecordSpacesTest.class differ
diff --git a/leetcode/target/test-classes/RemoveDuplicatesTest.class b/leetcode/target/test-classes/RemoveDuplicatesTest.class
new file mode 100644
index 0000000..87b4e5d
Binary files /dev/null and b/leetcode/target/test-classes/RemoveDuplicatesTest.class differ
diff --git a/leetcode/target/test-classes/RemoveZeroSumSublistsTest.class b/leetcode/target/test-classes/RemoveZeroSumSublistsTest.class
new file mode 100644
index 0000000..f722d5b
Binary files /dev/null and b/leetcode/target/test-classes/RemoveZeroSumSublistsTest.class differ
diff --git a/leetcode/target/test-classes/ReorderListIITest.class b/leetcode/target/test-classes/ReorderListIITest.class
new file mode 100644
index 0000000..30858fc
Binary files /dev/null and b/leetcode/target/test-classes/ReorderListIITest.class differ
diff --git a/leetcode/target/test-classes/ReorderListTest.class b/leetcode/target/test-classes/ReorderListTest.class
new file mode 100644
index 0000000..4e5681d
Binary files /dev/null and b/leetcode/target/test-classes/ReorderListTest.class differ
diff --git a/leetcode/target/test-classes/ReverseBitsTest.class b/leetcode/target/test-classes/ReverseBitsTest.class
new file mode 100644
index 0000000..d7ddfcd
Binary files /dev/null and b/leetcode/target/test-classes/ReverseBitsTest.class differ
diff --git a/leetcode/target/test-classes/ReverseLeftWordsTest.class b/leetcode/target/test-classes/ReverseLeftWordsTest.class
new file mode 100644
index 0000000..8725690
Binary files /dev/null and b/leetcode/target/test-classes/ReverseLeftWordsTest.class differ
diff --git a/leetcode/target/test-classes/ReverseListTest.class b/leetcode/target/test-classes/ReverseListTest.class
new file mode 100644
index 0000000..12879fb
Binary files /dev/null and b/leetcode/target/test-classes/ReverseListTest.class differ
diff --git a/leetcode/target/test-classes/ReverseWords2Test.class b/leetcode/target/test-classes/ReverseWords2Test.class
new file mode 100644
index 0000000..346a64f
Binary files /dev/null and b/leetcode/target/test-classes/ReverseWords2Test.class differ
diff --git a/leetcode/target/test-classes/ReverseWordsTest.class b/leetcode/target/test-classes/ReverseWordsTest.class
new file mode 100644
index 0000000..289e641
Binary files /dev/null and b/leetcode/target/test-classes/ReverseWordsTest.class differ
diff --git a/leetcode/target/test-classes/Rob2Test.class b/leetcode/target/test-classes/Rob2Test.class
new file mode 100644
index 0000000..74c350d
Binary files /dev/null and b/leetcode/target/test-classes/Rob2Test.class differ
diff --git a/leetcode/target/test-classes/RobTest.class b/leetcode/target/test-classes/RobTest.class
new file mode 100644
index 0000000..6f908c7
Binary files /dev/null and b/leetcode/target/test-classes/RobTest.class differ
diff --git a/leetcode/target/test-classes/SearchIITest.class b/leetcode/target/test-classes/SearchIITest.class
new file mode 100644
index 0000000..6cc6f3d
Binary files /dev/null and b/leetcode/target/test-classes/SearchIITest.class differ
diff --git a/leetcode/target/test-classes/SearchMatrixIITest.class b/leetcode/target/test-classes/SearchMatrixIITest.class
new file mode 100644
index 0000000..040a776
Binary files /dev/null and b/leetcode/target/test-classes/SearchMatrixIITest.class differ
diff --git a/leetcode/target/test-classes/SearchRangeTest.class b/leetcode/target/test-classes/SearchRangeTest.class
new file mode 100644
index 0000000..ffd5841
Binary files /dev/null and b/leetcode/target/test-classes/SearchRangeTest.class differ
diff --git a/leetcode/target/test-classes/SearchTest.class b/leetcode/target/test-classes/SearchTest.class
new file mode 100644
index 0000000..b056dd8
Binary files /dev/null and b/leetcode/target/test-classes/SearchTest.class differ
diff --git a/leetcode/target/test-classes/SimplifyPathTest.class b/leetcode/target/test-classes/SimplifyPathTest.class
new file mode 100644
index 0000000..34d497a
Binary files /dev/null and b/leetcode/target/test-classes/SimplifyPathTest.class differ
diff --git a/leetcode/target/test-classes/SortColorsTest.class b/leetcode/target/test-classes/SortColorsTest.class
new file mode 100644
index 0000000..1a5431e
Binary files /dev/null and b/leetcode/target/test-classes/SortColorsTest.class differ
diff --git a/leetcode/target/test-classes/SpiralOrderTest.class b/leetcode/target/test-classes/SpiralOrderTest.class
new file mode 100644
index 0000000..65bfce6
Binary files /dev/null and b/leetcode/target/test-classes/SpiralOrderTest.class differ
diff --git a/leetcode/target/test-classes/SplitIntoFibonacciTest.class b/leetcode/target/test-classes/SplitIntoFibonacciTest.class
new file mode 100644
index 0000000..aeb87fc
Binary files /dev/null and b/leetcode/target/test-classes/SplitIntoFibonacciTest.class differ
diff --git a/leetcode/target/test-classes/StrStrTest.class b/leetcode/target/test-classes/StrStrTest.class
new file mode 100644
index 0000000..02df104
Binary files /dev/null and b/leetcode/target/test-classes/StrStrTest.class differ
diff --git a/leetcode/target/test-classes/SubsetsTest.class b/leetcode/target/test-classes/SubsetsTest.class
new file mode 100644
index 0000000..f858996
Binary files /dev/null and b/leetcode/target/test-classes/SubsetsTest.class differ
diff --git a/leetcode/target/test-classes/SubsetsWithDupTest.class b/leetcode/target/test-classes/SubsetsWithDupTest.class
new file mode 100644
index 0000000..a3d2bd5
Binary files /dev/null and b/leetcode/target/test-classes/SubsetsWithDupTest.class differ
diff --git a/leetcode/target/test-classes/SwapPairsTest.class b/leetcode/target/test-classes/SwapPairsTest.class
new file mode 100644
index 0000000..fefb0d8
Binary files /dev/null and b/leetcode/target/test-classes/SwapPairsTest.class differ
diff --git a/leetcode/target/test-classes/ThreeSumClosestTest.class b/leetcode/target/test-classes/ThreeSumClosestTest.class
new file mode 100644
index 0000000..d15bd08
Binary files /dev/null and b/leetcode/target/test-classes/ThreeSumClosestTest.class differ
diff --git a/leetcode/target/test-classes/ThreeSumSmallerTest.class b/leetcode/target/test-classes/ThreeSumSmallerTest.class
new file mode 100644
index 0000000..7a1fdc6
Binary files /dev/null and b/leetcode/target/test-classes/ThreeSumSmallerTest.class differ
diff --git a/leetcode/target/test-classes/ThreeSumTest.class b/leetcode/target/test-classes/ThreeSumTest.class
new file mode 100644
index 0000000..7ead027
Binary files /dev/null and b/leetcode/target/test-classes/ThreeSumTest.class differ
diff --git a/leetcode/target/test-classes/TrapTest.class b/leetcode/target/test-classes/TrapTest.class
new file mode 100644
index 0000000..426a5b8
Binary files /dev/null and b/leetcode/target/test-classes/TrapTest.class differ
diff --git a/leetcode/target/test-classes/ValidateStackSequencesTest.class b/leetcode/target/test-classes/ValidateStackSequencesTest.class
new file mode 100644
index 0000000..46964e3
Binary files /dev/null and b/leetcode/target/test-classes/ValidateStackSequencesTest.class differ
diff --git a/leetcode/target/test-classes/ZigZagConvertTest.class b/leetcode/target/test-classes/ZigZagConvertTest.class
new file mode 100644
index 0000000..e2a323a
Binary files /dev/null and b/leetcode/target/test-classes/ZigZagConvertTest.class differ
diff --git a/offer/pom.xml b/offer/pom.xml
new file mode 100644
index 0000000..918bdde
--- /dev/null
+++ b/offer/pom.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.andy</groupId>
+    <artifactId>offer</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+
+</project>
\ No newline at end of file
diff --git a/offer/src/main/java/AddBinary.java b/offer/src/main/java/AddBinary.java
new file mode 100644
index 0000000..be00667
--- /dev/null
+++ b/offer/src/main/java/AddBinary.java
@@ -0,0 +1,38 @@
+public class AddBinary {
+    public String addBinary(String a, String b) {
+        StringBuilder res = new StringBuilder();
+
+        int first = a.length()-1, second = b.length()-1;
+        int p = Math.max(first, second);
+        int carry = 0;
+
+        while(p>=0) {
+            int t1 = 0, t2=0;
+            if(first>=0) {
+                t1 = a.charAt(first)-'0';
+            }
+            if(second>=0) {
+                t2 = b.charAt(second)-'0';
+            }
+            int temp = t1 + t2 + carry;
+            carry = 0;
+            if(temp>1) {
+                carry = 1;
+                temp = temp-2;
+            }
+            res.insert(0, temp);
+            first--;
+            second--;
+            p--;
+        }
+
+
+        if(carry>0) {
+            res.insert(0, '1');
+        }
+
+        return res.toString();
+    }
+
+
+}
diff --git a/offer/src/main/java/CheckInclusion.java b/offer/src/main/java/CheckInclusion.java
new file mode 100644
index 0000000..281a302
--- /dev/null
+++ b/offer/src/main/java/CheckInclusion.java
@@ -0,0 +1,51 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+/**
+ * 014/567 字符串中的变位
+ */
+
+public class CheckInclusion {
+
+    public boolean checkInclusion(String s1, String s2) {
+        boolean res = false;
+        int[] arr1= new int[26];
+        int[] arr2 = new int[26];
+
+        if(s1.length()>s2.length()) {
+            return false;
+        }
+
+        for(int i=0; i<s1.length(); i++) {
+            char c1 = s1.charAt(i);
+            char c2 = s2.charAt(i);
+            arr1[c1-'a'] += 1;
+            arr2[c2-'a'] += 1;
+        }
+        if(Arrays.equals(arr1, arr2)) {
+            return true;
+        }
+
+        int left=0, right=s1.length();
+
+        while(right<s2.length()) {
+            int c1 = s2.charAt(left) - 'a';
+            int c2 = s2.charAt(right) - 'a';
+            arr2[c1]--;
+            arr2[c2]++;
+            if(Arrays.equals(arr1, arr2)) {
+                return true;
+            }
+
+            left++;
+            right++;
+        }
+        return res;
+    }
+
+
+
+
+}
diff --git a/offer/src/main/java/CheckInclusionII.java b/offer/src/main/java/CheckInclusionII.java
new file mode 100644
index 0000000..c2a26dd
--- /dev/null
+++ b/offer/src/main/java/CheckInclusionII.java
@@ -0,0 +1,57 @@
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * 014/567 字符串中的变位
+ */
+
+public class CheckInclusionII {
+
+    public boolean checkInclusion(String s1, String s2) {
+        boolean res = false;
+        HashMap<Character, Integer> map1 = new HashMap<>();
+        HashMap<Character, Integer> map2 = new HashMap<>();
+        int count=0;
+
+        for(int i=0; i<s1.length(); i++) {
+            char c = s1.charAt(i);
+            map1.put(c, map1.getOrDefault(c, 0)+1);
+        }
+
+
+        int left=0, right=0;
+
+        while(right<s2.length()) {
+            // 左窗口右移
+            if(right-left>=s1.length()) {
+                char t = s2.charAt(left);
+                map2.put(t, map2.get(t)-1);
+                // 左指针移除的是有效字符，并且map1[t]>map2[t]，那么有效字符数量减1
+                if(map1.getOrDefault(t,0)>map2.get(t)) {
+                    count--;
+                }
+                // 左指针右移
+                left++;
+            }
+
+            // 右窗口右移
+            char c = s2.charAt(right);
+            map2.put(c, map2.getOrDefault(c, 0)+1);
+
+            // 判断有效字符的个数
+            if(map2.get(c)<= map1.getOrDefault(c, 0)) {
+                count++;
+            }
+
+            if(count==s1.length()) {
+                return true;
+            }
+            right++;
+        }
+        return res;
+    }
+
+
+
+
+}
diff --git a/offer/src/main/java/CountBits.java b/offer/src/main/java/CountBits.java
new file mode 100644
index 0000000..da83995
--- /dev/null
+++ b/offer/src/main/java/CountBits.java
@@ -0,0 +1,25 @@
+/**
+ * 003/338 前n个数字的二进制中1的个数
+ */
+
+public class CountBits {
+
+    public int[] countBits(int n) {
+        int[] res = new int[n+1];
+        for(int i=0; i<=n; i++) {
+            res[i] = bits(i);
+        }
+
+        return res;
+    }
+
+    int bits(int n) {
+        int count = 0;
+        while(n>0) {
+            count+=n%2;
+            n = n>>1;
+        }
+
+        return count;
+    }
+}
diff --git a/offer/src/main/java/CountSubstrings.java b/offer/src/main/java/CountSubstrings.java
new file mode 100644
index 0000000..b050c12
--- /dev/null
+++ b/offer/src/main/java/CountSubstrings.java
@@ -0,0 +1,41 @@
+/**
+ * `020/647 回文子字符串的个数`
+ */
+
+
+public class CountSubstrings {
+    public int countSubstrings(String s) {
+        int res = 0;
+        int left, right;
+        for(int i=0; i<s.length(); i++) {
+            res++;
+
+            // 奇数
+            left=i-1;
+            right=i+1;
+            while(left>=0 && right<s.length()) {
+                if(s.charAt(left)==s.charAt(right)) {
+                    res++;
+                    left--;
+                    right++;
+                }else {
+                    break;
+                }
+            }
+
+            // 偶数
+            left=i-1;
+            right=i;
+            while (left>=0 && right<s.length()) {
+                if(s.charAt(left)==s.charAt(right)) {
+                    res++;
+                    left--;
+                    right++;
+                }else {
+                    break;
+                }
+            }
+        }
+        return res;
+    }
+}
diff --git a/offer/src/main/java/DetectCycle.java b/offer/src/main/java/DetectCycle.java
new file mode 100644
index 0000000..40b1e1b
--- /dev/null
+++ b/offer/src/main/java/DetectCycle.java
@@ -0,0 +1,27 @@
+/**
+ * 022/142 链表中环的入口节点
+ */
+
+public class DetectCycle {
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow=head, fast=head;
+        while(fast!=null) {
+            slow = slow.next;
+            if(fast.next==null || fast.next.next==null) {
+                return null;
+            }
+            fast = fast.next.next;
+            if(slow==fast) {
+                break;
+            }
+        }
+
+        slow = head;
+        while (slow!=fast) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        return slow;
+    }
+}
diff --git a/offer/src/main/java/Divide.java b/offer/src/main/java/Divide.java
new file mode 100644
index 0000000..24d8c7a
--- /dev/null
+++ b/offer/src/main/java/Divide.java
@@ -0,0 +1,16 @@
+import java.util.HashMap;
+
+/**
+ * 001/29 整数除法
+ */
+
+public class Divide {
+    public int divide(int a, int b) {
+        int res = 0;
+        HashMap<Integer, Integer> map = new HashMap<>();
+        boolean negative = false;
+
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/FindAnagrams.java b/offer/src/main/java/FindAnagrams.java
new file mode 100644
index 0000000..e60c7ef
--- /dev/null
+++ b/offer/src/main/java/FindAnagrams.java
@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 015/438 字符串中所有的变位词
+ */
+
+public class FindAnagrams {
+    public List<Integer> findAnagrams(String s, String p) {
+        List<Integer> res = new ArrayList<>();
+        int[] arr1 = new int[26];
+        int[] arr2 = new int[26];
+        if(s.length()<p.length()) {
+            return res;
+        }
+
+        for(int i=0; i<p.length(); i++) {
+            arr1[s.charAt(i)-'a']++;
+            arr2[p.charAt(i)-'a']++;
+        }
+
+        if(Arrays.equals(arr1, arr2)) {
+            res.add(0);
+        }
+
+        for(int i=p.length(); i<s.length(); i++) {
+            int preIndex = s.charAt(i-p.length())-'a';
+            int curIndex = s.charAt(i)-'a';
+            arr1[preIndex]--;
+            arr1[curIndex]++;
+            if(Arrays.equals(arr1, arr2)) {
+                res.add(i+1-p.length());
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/FindMaxLength.java b/offer/src/main/java/FindMaxLength.java
new file mode 100644
index 0000000..2aa50b5
--- /dev/null
+++ b/offer/src/main/java/FindMaxLength.java
@@ -0,0 +1,36 @@
+import java.util.Arrays;
+import java.util.HashMap;
+
+/**
+ * 011/525 0和1个数相同的子数组
+ */
+
+public class FindMaxLength {
+    public int findMaxLength(int[] nums) {
+        int res = 0;
+        int count=0;
+        HashMap<Integer, Integer> map = new HashMap<>();
+        map.put(0, -1); // 在默认索引从-1开始
+
+        for(int i=0; i<nums.length; i++) {
+            // 求前缀和。将0设置为-1
+            if(nums[i]==0) {
+                count--;
+            }else {
+                count++;
+            }
+
+            // 若相等，那么表明存储的索引与当前索引的和为0
+            if(map.containsKey(count)) {
+                res = Math.max(res, i-map.get(count));
+            }else {
+                map.put(count, i);
+            }
+
+        }
+
+        return res;
+    }
+
+
+}
diff --git a/offer/src/main/java/IntersectionNode.java b/offer/src/main/java/IntersectionNode.java
new file mode 100644
index 0000000..6522e6b
--- /dev/null
+++ b/offer/src/main/java/IntersectionNode.java
@@ -0,0 +1,25 @@
+/**
+ * 023/160 两个链表的第一个重合点
+ */
+
+public class IntersectionNode {
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        ListNode l1 = headA;
+        ListNode l2 = headB;
+
+        // headA-headB与headB-headA一定会有交点，最不济交点为null
+        while(l1 != l2) {
+            l1 = l1.next;
+            l2 = l2.next;
+            if(l1==null && l2==null) {
+                return null;
+            }else if(l1==null) {
+                l1=headB;
+            }else if(l2==null) {
+                l2=headA;
+            }
+        }
+        return l1;
+    }
+
+}
diff --git a/offer/src/main/java/IsPalindrome.java b/offer/src/main/java/IsPalindrome.java
new file mode 100644
index 0000000..2d488de
--- /dev/null
+++ b/offer/src/main/java/IsPalindrome.java
@@ -0,0 +1,35 @@
+/**
+ * 018/125 判断是否为回文串
+ */
+
+public class IsPalindrome {
+
+    public boolean isPalindrome(String s) {
+        s = s.toLowerCase();
+        boolean res = true;
+        int left=0, right=s.length()-1;
+
+        while (left<right) {
+            char cl = s.charAt(left);
+            if(('a'> cl || cl>'z') && ('0'>cl || '9'<cl)) {
+                left++;
+                continue;
+            }
+
+            char cr = s.charAt(right);
+            if(('a'> cr || cr>'z') && ('0'>cr || '9'<cr)) {
+                right--;
+                continue;
+            }
+
+            if(s.charAt(left)==s.charAt(right)) {
+                left++;
+                right--;
+            }else {
+                res = false;
+                break;
+            }
+        }
+        return res;
+    }
+}
diff --git a/offer/src/main/java/LengthOfLongestSubstring.java b/offer/src/main/java/LengthOfLongestSubstring.java
new file mode 100644
index 0000000..03a45e5
--- /dev/null
+++ b/offer/src/main/java/LengthOfLongestSubstring.java
@@ -0,0 +1,30 @@
+import java.util.HashMap;
+
+/**
+ * 016/3 不含重复字符的最长字符串
+ */
+
+public class LengthOfLongestSubstring {
+
+    public int lengthOfLongestSubstring(String s) {
+        int res = 0;
+        HashMap<Character, Integer> map = new HashMap<>();
+        int left=0, right=0;
+        while(right<s.length()) {
+            char cr = s.charAt(right);
+            map.put(cr, map.getOrDefault(cr, 0)+1);
+
+            while(map.get(cr)==2) {
+                char cl = s.charAt(left);
+                map.put(cl, map.get(cl)-1);
+                left++;
+            }
+
+            res = Math.max(res, right-left+1);
+
+            right++;
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/ListNode.java b/offer/src/main/java/ListNode.java
new file mode 100644
index 0000000..f99c467
--- /dev/null
+++ b/offer/src/main/java/ListNode.java
@@ -0,0 +1,54 @@
+import org.w3c.dom.ls.LSInput;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListNode {
+    int val;
+    ListNode next;
+    ListNode() {}
+    ListNode(int val) {
+        this.val = val;
+    }
+    ListNode(int val, ListNode next) {
+        this.val = val;
+        this.next = next;
+    }
+
+    public static ListNode numToList(int[] nums) {
+        ListNode dummy = new ListNode(-1);
+        ListNode curr = dummy;
+        for(int n: nums) {
+            curr.next = new ListNode(n);
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+
+    public static List<Integer> listToArrayList(ListNode head) {
+        List<Integer> arr = new ArrayList<Integer>();
+        while (head!=null) {
+            arr.add(head.val);
+            head = head.next;
+        }
+        return arr;
+    }
+
+    public static ListNode merge(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(-1);
+        ListNode curr = dummy;
+        while (l1!=null) {
+            curr.next = l1;
+            curr = curr.next;
+            l1 = l1.next;
+        }
+
+        while (l2!=null) {
+            curr.next = l2;
+            curr = curr.next;
+            l2 = l2.next;
+        }
+
+        return dummy.next;
+    }
+}
diff --git a/offer/src/main/java/MinSubArrayLength.java b/offer/src/main/java/MinSubArrayLength.java
new file mode 100644
index 0000000..df83fbc
--- /dev/null
+++ b/offer/src/main/java/MinSubArrayLength.java
@@ -0,0 +1,30 @@
+import java.util.Arrays;
+
+/**
+ * 008/209 和大于等于target的最短数组
+ */
+
+public class MinSubArrayLength {
+    public int minSubArrayLen(int target, int[] nums) {
+        int res = Integer.MAX_VALUE;
+
+        int left=0, right=0;
+        int sum = 0;
+        while(right<nums.length) {
+            sum += nums[right];
+
+            while (sum>=target) {
+                res= Math.min(right-left+1, res);
+                sum -= nums[left];
+                left++;
+            }
+           right++;
+        }
+
+        if(res==Integer.MAX_VALUE) {
+            return 0;
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/MinWindow.java b/offer/src/main/java/MinWindow.java
new file mode 100644
index 0000000..a30289b
--- /dev/null
+++ b/offer/src/main/java/MinWindow.java
@@ -0,0 +1,44 @@
+import java.util.HashMap;
+
+/**
+ * 017/76 含有所有字符的最短字符串
+ */
+
+public class MinWindow {
+    public String minWindow(String s, String t) {
+        String res="";
+        int count=0; // 窗口内含有有效字符的个数
+
+        HashMap<Character, Integer> mapt = new HashMap<>();
+        HashMap<Character, Integer> maps = new HashMap<>();
+        for(int i=0; i<t.length(); i++) {
+            char c = t.charAt(i);
+            mapt.put(c, mapt.getOrDefault(c, 0)+1);
+        }
+
+        int left=0;
+        for(int i=0; i<s.length(); i++) {
+            char c  = s.charAt(i);
+            maps.put(c, maps.getOrDefault(c, 0)+1);
+            // 这里maps[c]>=1，c为有效值
+            if(maps.get(c)<= mapt.getOrDefault(c, 0)) {
+                count++;
+            }
+
+            // 右移左边界
+            while(left<=i && mapt.getOrDefault(s.charAt(left), 0)<maps.getOrDefault(s.charAt(left), 0)) {
+                maps.put(s.charAt(left), maps.get(s.charAt(left))-1);
+                left++;
+            }
+
+
+            if(count==t.length()) {
+                if(res.equals("") || res.length()>i+1-left) {
+                    res = s.substring(left, i+1);
+                }
+            }
+        }
+        return res;
+
+    }
+}
diff --git a/offer/src/main/java/NumMatrix.java b/offer/src/main/java/NumMatrix.java
new file mode 100644
index 0000000..169ccc0
--- /dev/null
+++ b/offer/src/main/java/NumMatrix.java
@@ -0,0 +1,21 @@
+/**
+ * 013/304 二维矩阵的和
+ */
+
+public class NumMatrix {
+    int[][] prefix;
+
+    public NumMatrix(int[][] matrix) {
+        prefix = new int[matrix.length+1][matrix[0].length+1];
+        for(int i=0; i<matrix.length; i++) {
+            for(int j=0; j<matrix[0].length; j++) {
+                prefix[i+1][j+1] = prefix[i][j+1]+prefix[i+1][j] - prefix[i][j]+matrix[i][j];
+            }
+        }
+
+    }
+
+    public int sumRegion(int row1, int col1, int row2, int col2) {
+        return prefix[row2+1][col2+1]+prefix[row1][col1]-prefix[row1][col2+1]-prefix[row2+1][col1];
+    }
+}
diff --git a/offer/src/main/java/NumSubArrayProductLessThanK.java b/offer/src/main/java/NumSubArrayProductLessThanK.java
new file mode 100644
index 0000000..4d7a8ad
--- /dev/null
+++ b/offer/src/main/java/NumSubArrayProductLessThanK.java
@@ -0,0 +1,32 @@
+import java.util.Arrays;
+
+/**
+ * 009/713 乘积小于K的子数组
+ */
+
+
+public class NumSubArrayProductLessThanK {
+
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        int res = 0;
+        int low=0, high=0;
+
+        while (low<nums.length) {
+            int left = nums[low];
+            int sum = 1;
+            high = low;
+            while(high<nums.length) {
+                sum = sum*nums[high];
+                if(sum>=k) {
+                    break;
+                }
+                high++;
+                res++;
+            }
+            low++;
+        }
+        return res;
+
+    }
+
+}
diff --git a/offer/src/main/java/PivotIndex.java b/offer/src/main/java/PivotIndex.java
new file mode 100644
index 0000000..02a0eca
--- /dev/null
+++ b/offer/src/main/java/PivotIndex.java
@@ -0,0 +1,38 @@
+/**
+ * 012/724 左右两边子数组的和相等
+ */
+
+public class PivotIndex {
+    public int pivotIndex(int[] nums) {
+        int res = -1;
+        if(nums.length==1) {
+            res=0;
+        }
+
+        int[] prefixSum = new int[nums.length];
+        for(int i=0; i<nums.length; i++) {
+            if(i==0) {
+                prefixSum[i] = nums[i];
+            }else {
+                prefixSum[i] = prefixSum[i-1]+nums[i];
+            }
+        }
+
+        for(int i=0; i<nums.length; i++) {
+            int value = prefixSum[nums.length-1]-prefixSum[i];
+            if(i==0) {
+                if(value==0) {
+                    res = 0;
+                    break;
+                }
+            }else {
+                if(prefixSum[i-1]==value){
+                    res = i;
+                    break;
+                }
+            }
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/PivotIndexII.java b/offer/src/main/java/PivotIndexII.java
new file mode 100644
index 0000000..aa98c30
--- /dev/null
+++ b/offer/src/main/java/PivotIndexII.java
@@ -0,0 +1,27 @@
+/**
+ * 012/724 左右两边子数组的和相等
+ */
+
+public class PivotIndexII {
+    public int pivotIndex(int[] nums) {
+        int res = -1;
+        int sum=0;
+
+        int[] prefixSum = new int[nums.length];
+        for(int i=0; i<nums.length; i++) {
+            sum += nums[i];
+            prefixSum[i] = sum;
+        }
+
+        sum=0;
+        for(int i=0; i<nums.length; i++) {
+            if(sum*2+nums[i]==prefixSum[nums.length-1]) {
+                res = i;
+                break;
+            }
+            sum = prefixSum[i];
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/PivotIndexIII.java b/offer/src/main/java/PivotIndexIII.java
new file mode 100644
index 0000000..51447e1
--- /dev/null
+++ b/offer/src/main/java/PivotIndexIII.java
@@ -0,0 +1,23 @@
+/**
+ * 012/724 左右两边子数组的和相等
+ */
+
+public class PivotIndexIII {
+    public int pivotIndex(int[] nums) {
+        int res = -1;
+
+        int[] prefixSum = new int[nums.length+1];
+        for(int i=1; i<prefixSum.length; i++) {
+            prefixSum[i] = prefixSum[i-1]+nums[i-1];
+        }
+
+
+        for(int i=1; i<prefixSum.length; i++) {
+            if(prefixSum[i-1]*2+nums[i-1]==prefixSum[prefixSum.length-1]) {
+                res = i-1;
+                break;
+            }
+        }
+        return res;
+    }
+}
diff --git a/offer/src/main/java/RemoveNthFromEnd.java b/offer/src/main/java/RemoveNthFromEnd.java
new file mode 100644
index 0000000..3d38b6a
--- /dev/null
+++ b/offer/src/main/java/RemoveNthFromEnd.java
@@ -0,0 +1,25 @@
+/**
+ * 021/19 删除链表的倒数第N个节点
+ */
+
+public class RemoveNthFromEnd {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        ListNode fast=dummy;
+        ListNode slow = dummy;
+        for(int i=0; i<=n; i++) {
+            fast = fast.next;
+        }
+
+        while(fast!=null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+
+        slow.next = slow.next.next;
+
+        return dummy.next;
+    }
+
+}
diff --git a/offer/src/main/java/RemoveNthFromEndII.java b/offer/src/main/java/RemoveNthFromEndII.java
new file mode 100644
index 0000000..3d5d5a0
--- /dev/null
+++ b/offer/src/main/java/RemoveNthFromEndII.java
@@ -0,0 +1,35 @@
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+/**
+ * 021/19 删除链表的倒数第N个节点
+ */
+
+public class RemoveNthFromEndII {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        Queue<ListNode>  queue= new LinkedList<>();
+        int count = 0;
+        while(head!=null) {
+            queue.add(head);
+            head = head.next;
+            count++;
+        }
+
+        ListNode dummy = new ListNode(-1);
+        ListNode curr  =dummy;
+        while(!queue.isEmpty()){
+            ListNode temp = queue.poll();
+            // 清除弹出节点的next值，这一步很有必要
+            temp.next = null;
+
+            if(count!=n) {
+                curr.next = temp;
+                curr = curr.next;
+            }
+            count--;
+        }
+        return dummy.next;
+    }
+
+}
diff --git a/offer/src/main/java/SingleNumber.java b/offer/src/main/java/SingleNumber.java
new file mode 100644
index 0000000..2399b1e
--- /dev/null
+++ b/offer/src/main/java/SingleNumber.java
@@ -0,0 +1,22 @@
+import java.util.HashMap;
+
+/**
+ * 004/137 只出现一次的数字
+ */
+
+public class SingleNumber {
+
+    public int singleNumber(int[] nums) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for(int n: nums) {
+            map.put(n, map.getOrDefault(n, 0)+1);
+        }
+
+        for(int key: map.keySet()) {
+            if(map.get(key)==1) {
+                return key;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/offer/src/main/java/SubArraySum.java b/offer/src/main/java/SubArraySum.java
new file mode 100644
index 0000000..bca7a98
--- /dev/null
+++ b/offer/src/main/java/SubArraySum.java
@@ -0,0 +1,25 @@
+/**
+ *  010/560 和为k的子数组
+ */
+public class SubArraySum {
+    public int subarraySum(int[] nums, int k) {
+        int res = 0;
+
+        int left=0, right=0;
+        int sum = 0;
+        while(left<nums.length) {
+            right = left;
+            sum = 0;
+            while(right<nums.length) {
+                sum += nums[right];
+                if(sum==k) {
+                    res++;
+                }
+                right++;
+            }
+            left++;
+        }
+
+        return res;
+    }
+}
diff --git a/offer/src/main/java/ThreeSum.java b/offer/src/main/java/ThreeSum.java
new file mode 100644
index 0000000..82cfbd9
--- /dev/null
+++ b/offer/src/main/java/ThreeSum.java
@@ -0,0 +1,59 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 007/15 数组中和为0的三个数
+ */
+
+public class ThreeSum {
+
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+
+        // 先从小到大排序
+        Arrays.sort(nums);
+        int p = 0;
+        while(p<nums.length) {
+            int left = nums[p];
+            List<List<Integer>> temp = twoSum(nums, p+1, -left);
+            for(List<Integer> t: temp) {
+                t.add(left);
+                res.add(t);
+            }
+            while(p<nums.length && left==nums[p]) {
+                p++;
+            }
+        }
+        return res;
+    }
+
+    List<List<Integer>> twoSum(int[] nums, int start, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        int low=start, high=nums.length-1;
+        while(low<high) {
+            int left = nums[low];
+            int right = nums[high];
+            int sum = left+right;
+            if(sum==target) {
+                List<Integer> temp = new ArrayList<>();
+                temp.add(left);
+                temp.add(right);
+                res.add(temp);
+                while(low<high && left==nums[low]) {
+                    low++;
+                }
+            }else if(sum<target) {
+                while(low<high && left==nums[low]) {
+                    low++;
+                }
+            }else {
+                while(low<high && right==nums[high]) {
+                    high--;
+                }
+            }
+        }
+        return res;
+    }
+
+}
diff --git a/offer/src/main/java/ThreeSumII.java b/offer/src/main/java/ThreeSumII.java
new file mode 100644
index 0000000..0e67b42
--- /dev/null
+++ b/offer/src/main/java/ThreeSumII.java
@@ -0,0 +1,80 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 007/15 数组中和为0的三个数
+ * labuladong 利用递归求解
+ */
+
+public class ThreeSumII {
+
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+
+        // 先从小到大排序
+        Arrays.sort(nums);
+
+        res = dp(nums, 0, 3, 0);
+
+        return res;
+    }
+
+    /**
+     *
+     * @param nums 数组
+     * @param start 遍历的起始点
+     * @param n 相加的数字个数
+     * @param target 目标和
+     * @return
+     */
+    List<List<Integer>> dp(int[] nums, int start, int n, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        if(n<2 || start>=nums.length) {
+            return res;
+        }
+
+        if(n==2) {
+            int low = start, high=nums.length-1;
+            while(low<high) {
+                int left=nums[low];
+                int right = nums[high];
+                int sum = left+right;
+                if(sum==target) {
+                    List<Integer> temp = new ArrayList<>();
+                    temp.add(left);
+                    temp.add(right);
+                    res.add(temp);
+                    while (low<high && left==nums[low]) {
+                        low++;
+                    }
+                }else if(sum<target) {
+                    while(low<high && left==nums[low]) {
+                        low++;
+                    }
+                }else {
+                    while(low<high && right==nums[high]) {
+                        high--;
+                    }
+                }
+            }
+        }else {
+            int p=start;
+            while(p<nums.length) {
+                int left = nums[p];
+                List<List<Integer>> temp = dp(nums, p+1, n-1, target-nums[p]);
+                for(List<Integer> t: temp) {
+                    t.add(nums[p]);
+                    res.add(t);
+                }
+                while(p<nums.length && left==nums[p]) {
+                    p++;
+                }
+            }
+        }
+        return res;
+    }
+
+
+
+}
diff --git a/offer/src/main/java/TwoIntegerDivide.java b/offer/src/main/java/TwoIntegerDivide.java
new file mode 100644
index 0000000..7362298
--- /dev/null
+++ b/offer/src/main/java/TwoIntegerDivide.java
@@ -0,0 +1,37 @@
+/**
+ * 001/29 整数整除
+ */
+
+public class TwoIntegerDivide {
+    public int divide(int a, int b) {
+        // 处理越界问题
+        if(a==Integer.MIN_VALUE && b==-1) {
+            return Integer.MAX_VALUE;
+        }
+
+        boolean negative = false;
+        if((a>0 && b<0) || (a<0 && b>0)) {
+            negative = true;
+        }
+
+        // 将整数都转换成负数，防止负数转换成整数导致越界
+        if(a>0){
+            a=-a;
+        }
+        if(b>0) {
+            b=-b;
+        }
+        int res = 0;
+
+        while(a<=b) {
+            res++;
+            a = a-b;
+        }
+
+        if(negative) {
+            res = -res;
+        }
+        return res;
+    }
+
+}
diff --git a/offer/src/main/java/TwoIntegerDivide2.java b/offer/src/main/java/TwoIntegerDivide2.java
new file mode 100644
index 0000000..8a003e1
--- /dev/null
+++ b/offer/src/main/java/TwoIntegerDivide2.java
@@ -0,0 +1,50 @@
+/**
+ * 001/29 整数整除
+ */
+
+public class TwoIntegerDivide2 {
+    public int divide(int a, int b) {
+        // 处理越界问题
+        if(a==Integer.MIN_VALUE && b==-1) {
+            return Integer.MAX_VALUE;
+        }
+
+        boolean negative = false;
+        if((a>0 && b<0) || (a<0 && b>0)) {
+            negative = true;
+        }
+
+        // 将整数都转换成负数，防止负数转换成整数导致越界
+        if(a>0){
+            a=-a;
+        }
+        if(b>0) {
+            b=-b;
+        }
+        int res = 0;
+
+        while(a<=b) {
+            int value =b;
+            int k = 1;
+
+            // 保证value + value不会溢出
+            // 0xc0000000 是十进制 -2^30 的十六进制的表示
+            // 判断 value >= 0xc0000000 的原因：保证 value + value 不会溢出
+            // 可以这样判断的原因是：0xc0000000 是最小值 -2^31 的一半，
+            // 而 a 的值不可能比 -2^31 还要小，所以 value 不可能比 0xc0000000 小
+            // -2^31 / 2 = -2^30
+            while(value>0xC0000000 && a<= value+value) {
+                value += value;
+                k += k;
+            }
+            res++;
+            a = a-b;
+        }
+
+        if(negative) {
+            res = -res;
+        }
+        return res;
+    }
+
+}
diff --git a/offer/src/main/java/TwoSum.java b/offer/src/main/java/TwoSum.java
new file mode 100644
index 0000000..9839bbb
--- /dev/null
+++ b/offer/src/main/java/TwoSum.java
@@ -0,0 +1,25 @@
+/**
+ * 006/167 排序数组中两个数字之和
+ */
+
+public class TwoSum {
+    public int[] twoSum(int[] numbers, int target) {
+        int[] res = new int[2];
+        int left=0, right=numbers.length-1;
+
+        while(left<right) {
+            int sum = numbers[left]+numbers[right];
+            if(sum==target) {
+                break;
+            }
+            if(sum>target) {
+                right--;
+            }else {
+                left++;
+            }
+        }
+        res[0] = left;
+        res[1] = right;
+        return res;
+    }
+}
diff --git a/offer/src/main/java/ValidPalindrome.java b/offer/src/main/java/ValidPalindrome.java
new file mode 100644
index 0000000..b2a99b8
--- /dev/null
+++ b/offer/src/main/java/ValidPalindrome.java
@@ -0,0 +1,31 @@
+/**
+ * 019/680 最多删除一个字符得到回文串
+ */
+
+public class ValidPalindrome {
+
+    public boolean validPalindrome(String s) {
+        int left=0, right=s.length()-1;
+        while(left<right) {
+            if(s.charAt(left)==s.charAt(right)) {
+                left++;
+                right--;
+            }else {
+                return isPalindrome(left+1, right, s) || isPalindrome(left, right-1, s);
+            }
+        }
+        return true;
+    }
+
+    boolean isPalindrome(int left, int right, String s) {
+        while (left<right) {
+            if(s.charAt(left)==s.charAt(right)) {
+                left++;
+                right--;
+            }else {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/offer/src/main/java/WordMaxProduct.java b/offer/src/main/java/WordMaxProduct.java
new file mode 100644
index 0000000..d05a260
--- /dev/null
+++ b/offer/src/main/java/WordMaxProduct.java
@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.HashSet;
+
+/**
+ * 005/318  单词长度最大乘积
+ */
+
+public class WordMaxProduct {
+    public int maxProduct(String[] words) {
+        int res = 0;
+        ArrayList<HashSet<Character>> sets = new ArrayList<HashSet<Character>>();
+
+        // 添加进入集合
+        for(int i=0; i<words.length; i++) {
+            HashSet<Character> set = new HashSet<>();
+            for(int j=0; j<words[i].length(); j++) {
+                set.add(words[i].charAt(j));
+            }
+            sets.add(set);
+        }
+
+        for(int i=0; i<sets.size(); i++) {
+            for(int j=i+1; j<sets.size(); j++) {
+                boolean valid = true;
+                for(char c: sets.get(j)) {
+                    if(sets.get(i).contains(c)) {
+                        valid = false;
+                        break;
+                    }
+                }
+                if(valid) {
+//                    System.out.println(words[i] + ", " + words[j]);
+                    res = Math.max(res, words[i].length() * words[j].length());
+                }
+            }
+        }
+        return res;
+
+    }
+}
diff --git a/offer/src/test/java/AddBinaryTest.java b/offer/src/test/java/AddBinaryTest.java
new file mode 100644
index 0000000..e81ed27
--- /dev/null
+++ b/offer/src/test/java/AddBinaryTest.java
@@ -0,0 +1,22 @@
+import org.junit.Test;
+
+public class AddBinaryTest {
+
+    AddBinary solver = new AddBinary();
+
+    @Test
+    public void testOne() {
+        String a = "11";
+        String b = "10";
+        String res = solver.addBinary(a, b);
+        System.out.println(res);
+    }
+
+    @Test
+    public void testTwo() {
+        String a = "1010";
+        String b = "1011";
+        String res = solver.addBinary(a, b);
+        System.out.println(res);
+    }
+}
diff --git a/offer/src/test/java/CheckInclusionIITest.java b/offer/src/test/java/CheckInclusionIITest.java
new file mode 100644
index 0000000..a6a5a39
--- /dev/null
+++ b/offer/src/test/java/CheckInclusionIITest.java
@@ -0,0 +1,51 @@
+import org.junit.Test;
+
+public class CheckInclusionIITest {
+
+    CheckInclusionII solver = new CheckInclusionII();
+
+    @Test
+    public void test1() {
+        String s1 = "ab";
+        String s2 = "eidbaooo";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test2() {
+        String s1 = "ab";
+        String s2 = "eidboaoo";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void test3() {
+        String s1 = "ab";
+        String s2 = "a";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void test4() {
+        String s1 = "adc";
+        String s2 = "dcda";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test5() {
+        String s1 = "hello";
+        String s2 = "ooolleoooleh";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/offer/src/test/java/CheckInclusionTest.java b/offer/src/test/java/CheckInclusionTest.java
new file mode 100644
index 0000000..f6554d2
--- /dev/null
+++ b/offer/src/test/java/CheckInclusionTest.java
@@ -0,0 +1,33 @@
+import org.junit.Test;
+
+public class CheckInclusionTest {
+
+    CheckInclusion solver = new CheckInclusion();
+
+    @Test
+    public void test1() {
+        String s1 = "ab";
+        String s2 = "eidbaooo";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test2() {
+        String s1 = "ab";
+        String s2 = "eidboaoo";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void test3() {
+        String s1 = "ab";
+        String s2 = "a";
+        boolean res = solver.checkInclusion(s1, s2);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/offer/src/test/java/CountBitsTest.java b/offer/src/test/java/CountBitsTest.java
new file mode 100644
index 0000000..81cdd6f
--- /dev/null
+++ b/offer/src/test/java/CountBitsTest.java
@@ -0,0 +1,21 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class CountBitsTest {
+    CountBits solver = new CountBits();
+
+    @Test
+    public void testOne() {
+        int[] res = solver.countBits(2);
+        System.out.println(Arrays.toString(res));
+        // [0, 1, 1]
+    }
+
+    @Test
+    public void testTwo() {
+        int[] res = solver.countBits(5);
+        System.out.println(Arrays.toString(res));
+        // [0, 1, 1, 2, 1, 2]
+    }
+}
diff --git a/offer/src/test/java/CountSubstringsTest.java b/offer/src/test/java/CountSubstringsTest.java
new file mode 100644
index 0000000..6662148
--- /dev/null
+++ b/offer/src/test/java/CountSubstringsTest.java
@@ -0,0 +1,23 @@
+import org.junit.Test;
+
+public class CountSubstringsTest {
+    CountSubstrings solver = new CountSubstrings();
+
+    @Test
+    public void test1() {
+        String s = "abc";
+        int res = solver.countSubstrings(s);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test2() {
+        String s = "aaa";
+        int res = solver.countSubstrings(s);
+        System.out.println(res);
+        // 6
+    }
+
+
+}
diff --git a/offer/src/test/java/DetectCycleTest.java b/offer/src/test/java/DetectCycleTest.java
new file mode 100644
index 0000000..d1f597b
--- /dev/null
+++ b/offer/src/test/java/DetectCycleTest.java
@@ -0,0 +1,27 @@
+import org.junit.Test;
+
+public class DetectCycleTest {
+    DetectCycle solver = new DetectCycle();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,2};
+        ListNode head = ListNode.numToList(nums);
+        head.next.next=head;
+        ListNode res = solver.detectCycle(head);
+        System.out.println(res.val);
+        // 1
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.detectCycle(head);
+        System.out.println(res);
+        // null
+    }
+
+}
+
+
diff --git a/offer/src/test/java/FindAnagramsTest.java b/offer/src/test/java/FindAnagramsTest.java
new file mode 100644
index 0000000..fa64c4f
--- /dev/null
+++ b/offer/src/test/java/FindAnagramsTest.java
@@ -0,0 +1,26 @@
+import org.junit.Test;
+
+import java.util.List;
+
+public class FindAnagramsTest {
+
+    FindAnagrams solver = new FindAnagrams();
+
+    @Test
+    public void test1() {
+        String s = "cbaebabacd";
+        String p = "abc";
+        List<Integer> res = solver.findAnagrams(s, p);
+        System.out.println(res);
+        // [0, 6]
+    }
+
+    @Test
+    public void test2() {
+        String s = "abab";
+        String p = "ab";
+        List<Integer> res = solver.findAnagrams(s, p);
+        System.out.println(res);
+        // [0, 1, 2]
+    }
+}
diff --git a/offer/src/test/java/FindMaxLengthTest.java b/offer/src/test/java/FindMaxLengthTest.java
new file mode 100644
index 0000000..bfef245
--- /dev/null
+++ b/offer/src/test/java/FindMaxLengthTest.java
@@ -0,0 +1,31 @@
+import org.junit.Test;
+
+public class FindMaxLengthTest {
+    FindMaxLength solver = new FindMaxLength();
+
+    @Test
+    public void testOne() {
+        int[] nums = {0, 1};
+        int res = solver.findMaxLength(nums);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = {0, 1, 0};
+        int res = solver.findMaxLength(nums);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testThree() {
+        int[] nums = {0, 1, 0, 1};
+        int res = solver.findMaxLength(nums);
+        System.out.println(res);
+        // 2
+    }
+
+
+}
diff --git a/offer/src/test/java/IntersectionNodeTest.java b/offer/src/test/java/IntersectionNodeTest.java
new file mode 100644
index 0000000..8b7ce14
--- /dev/null
+++ b/offer/src/test/java/IntersectionNodeTest.java
@@ -0,0 +1,31 @@
+import org.junit.Test;
+
+import java.util.List;
+
+public class IntersectionNodeTest {
+    IntersectionNode solver = new IntersectionNode();
+
+    @Test
+    public void test1() {
+        ListNode common = ListNode.numToList(new int[]{8,4,5});
+        ListNode headA = ListNode.numToList(new int[]{4,1});
+        ListNode headB = ListNode.numToList(new int[]{5,0,1});
+        headA = ListNode.merge(headA, common);
+        headB = ListNode.merge(headB, common);
+        ListNode res = solver.getIntersectionNode(headA, headB);
+        System.out.println(res.val);
+        // 8
+    }
+
+    @Test
+    public void test2() {
+        ListNode common = ListNode.numToList(new int[]{});
+        ListNode headA = ListNode.numToList(new int[]{2,6,4});
+        ListNode headB = ListNode.numToList(new int[]{1,5});
+        headA = ListNode.merge(headA, common);
+        headB = ListNode.merge(headB, common);
+        ListNode res = solver.getIntersectionNode(headA, headB);
+        System.out.println(res);
+        // null
+    }
+}
diff --git a/offer/src/test/java/IsPalindromeTest.java b/offer/src/test/java/IsPalindromeTest.java
new file mode 100644
index 0000000..2860192
--- /dev/null
+++ b/offer/src/test/java/IsPalindromeTest.java
@@ -0,0 +1,30 @@
+import org.junit.Test;
+
+public class IsPalindromeTest {
+
+    IsPalindrome solver = new IsPalindrome();
+
+    @Test
+    public void test1() {
+        String s = "A man, a plan, a canal: Panama";
+        boolean res = solver.isPalindrome(s);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test2() {
+        String s = "race a car";
+        boolean res = solver.isPalindrome(s);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void test3() {
+        String s = "0P";
+        boolean res = solver.isPalindrome(s);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/offer/src/test/java/LengthOfLongestSubstringTest.java b/offer/src/test/java/LengthOfLongestSubstringTest.java
new file mode 100644
index 0000000..5552351
--- /dev/null
+++ b/offer/src/test/java/LengthOfLongestSubstringTest.java
@@ -0,0 +1,37 @@
+import org.junit.Test;
+
+public class LengthOfLongestSubstringTest {
+    LengthOfLongestSubstring solver = new LengthOfLongestSubstring();
+
+    @Test
+    public void test1() {
+        String s = "abcabcbb";
+        int res = solver.lengthOfLongestSubstring(s);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test2() {
+        String s = "bbbbb";
+        int res = solver.lengthOfLongestSubstring(s);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void test3() {
+        String s = "pwwkew";
+        int res = solver.lengthOfLongestSubstring(s);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test4() {
+        String s = "tmmzuxt";
+        int res = solver.lengthOfLongestSubstring(s);
+        System.out.println(res);
+        // 5
+    }
+}
diff --git a/offer/src/test/java/MinSubArrayLengthTest.java b/offer/src/test/java/MinSubArrayLengthTest.java
new file mode 100644
index 0000000..d8658a6
--- /dev/null
+++ b/offer/src/test/java/MinSubArrayLengthTest.java
@@ -0,0 +1,42 @@
+import org.junit.Test;
+
+public class MinSubArrayLengthTest {
+
+    MinSubArrayLength solver = new MinSubArrayLength();
+
+    @Test
+    public void testOne() {
+        int target = 7;
+        int[] nums = new int[] {2,3,1,2,4,3};
+        int res = solver.minSubArrayLen(target, nums);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testTwo() {
+        int target = 4;
+        int[] nums = new int[] {1, 4, 4};
+        int res = solver.minSubArrayLen(target, nums);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testThree() {
+        int target = 11;
+        int[] nums = new int[] {1,1,1,1,1,1,1,1};
+        int res = solver.minSubArrayLen(target, nums);
+        System.out.println(res);
+        // 0
+    }
+
+    @Test
+    public void testFour() {
+        int target = 213;
+        int[] nums = new int[] {12,28,83,4,25,26,25,2,25,25,25,12};
+        int res = solver.minSubArrayLen(target, nums);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/offer/src/test/java/MinWindowTest.java b/offer/src/test/java/MinWindowTest.java
new file mode 100644
index 0000000..8e08db8
--- /dev/null
+++ b/offer/src/test/java/MinWindowTest.java
@@ -0,0 +1,50 @@
+import org.junit.Test;
+
+public class MinWindowTest {
+    MinWindow solver = new MinWindow();
+
+    @Test
+    public void test1() {
+        String s = "ADOBECODEBANC";
+        String t = "ABC";
+        String res = solver.minWindow(s, t);
+        System.out.println(res);
+        // BANC
+    }
+
+    @Test
+    public void test2() {
+        String s = "a";
+        String t = "a";
+        String res = solver.minWindow(s, t);
+        System.out.println(res);
+        // a
+    }
+
+    @Test
+    public void test3() {
+        String s = "a";
+        String t = "aa";
+        String res = solver.minWindow(s, t);
+        System.out.println(res);
+        // ""
+    }
+
+    @Test
+    public void test4() {
+        String s = "abc";
+        String t = "b";
+        String res = solver.minWindow(s, t);
+        System.out.println(res);
+        // b
+    }
+
+    @Test
+    public void test5() {
+        String s = "a";
+        String t = "b";
+        String res = solver.minWindow(s, t);
+        System.out.println(res);
+        // ""
+    }
+}
diff --git a/offer/src/test/java/NumMatrixTest.java b/offer/src/test/java/NumMatrixTest.java
new file mode 100644
index 0000000..80106ff
--- /dev/null
+++ b/offer/src/test/java/NumMatrixTest.java
@@ -0,0 +1,34 @@
+import org.junit.Test;
+
+public class NumMatrixTest {
+
+    @Test
+    public void test1() {
+        int[][] matrix = {
+                {3, 0, 1, 4, 2},
+                {5, 6, 3, 2, 1},
+                {1, 2, 0, 1, 5},
+                {4, 1, 0, 1, 7},
+                {1, 0, 3, 0, 5},
+        };
+        NumMatrix solver = new NumMatrix(matrix);
+        int res1 = solver.sumRegion(2,1,4,3);
+        int res2 = solver.sumRegion(1,1,2,2);
+        int res3 = solver.sumRegion(1,2,2,4);
+        System.out.println(res1 +", "+ res2 +", "+ res3);
+        // 8, 11, 12
+    }
+
+    @Test
+    public void test2() {
+        int[][] matrix = {
+                {-4, -5},
+        };
+        NumMatrix solver = new NumMatrix(matrix);
+        int res1 = solver.sumRegion(0,0,0,0);
+        int res2 = solver.sumRegion(0,0,0,1);
+        int res3 = solver.sumRegion(0,1,0,1);
+        System.out.println(res1 +", "+ res2 +", "+ res3);
+        // -4, -9, -5
+    }
+}
diff --git a/offer/src/test/java/NumSubArrayProductLessThanKTest.java b/offer/src/test/java/NumSubArrayProductLessThanKTest.java
new file mode 100644
index 0000000..be03829
--- /dev/null
+++ b/offer/src/test/java/NumSubArrayProductLessThanKTest.java
@@ -0,0 +1,32 @@
+import org.junit.Test;
+
+public class NumSubArrayProductLessThanKTest {
+    NumSubArrayProductLessThanK solver = new NumSubArrayProductLessThanK();
+
+    @Test
+    public void testOne() {
+        int[] nums = {10, 5, 2, 6};
+        int k = 100;
+        int res = solver.numSubarrayProductLessThanK(nums, k);
+        System.out.println(res);
+        // 8
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = {1, 2, 3};
+        int k = 0;
+        int res = solver.numSubarrayProductLessThanK(nums, k);
+        System.out.println(res);
+        // 0
+    }
+
+    @Test
+    public void testThree() {
+        int[] nums = {10,9,10,4,3,8,3,3,6,2,10,10,9,3};
+        int k = 19;
+        int res = solver.numSubarrayProductLessThanK(nums, k);
+        System.out.println(res);
+        // 18
+    }
+}
diff --git a/offer/src/test/java/PivotIndexIIITest.java b/offer/src/test/java/PivotIndexIIITest.java
new file mode 100644
index 0000000..a1ca1c3
--- /dev/null
+++ b/offer/src/test/java/PivotIndexIIITest.java
@@ -0,0 +1,30 @@
+import org.junit.Test;
+
+public class PivotIndexIIITest {
+
+    PivotIndexIII solver = new PivotIndexIII();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,7,3,6,5,6};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1,2,3};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // -1
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = {2,1,-1};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/offer/src/test/java/PivotIndexIITest.java b/offer/src/test/java/PivotIndexIITest.java
new file mode 100644
index 0000000..2e9d968
--- /dev/null
+++ b/offer/src/test/java/PivotIndexIITest.java
@@ -0,0 +1,30 @@
+import org.junit.Test;
+
+public class PivotIndexIITest {
+
+    PivotIndexII solver = new PivotIndexII();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,7,3,6,5,6};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1,2,3};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // -1
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = {2,1,-1};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/offer/src/test/java/PivotIndexTest.java b/offer/src/test/java/PivotIndexTest.java
new file mode 100644
index 0000000..2fa420e
--- /dev/null
+++ b/offer/src/test/java/PivotIndexTest.java
@@ -0,0 +1,30 @@
+import org.junit.Test;
+
+public class PivotIndexTest {
+
+    PivotIndex solver = new PivotIndex();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,7,3,6,5,6};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1,2,3};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // -1
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = {2,1,-1};
+        int res = solver.pivotIndex(nums);
+        System.out.println(res);
+        // 0
+    }
+}
diff --git a/offer/src/test/java/RemoveNthFromEndIITest.java b/offer/src/test/java/RemoveNthFromEndIITest.java
new file mode 100644
index 0000000..4245ec1
--- /dev/null
+++ b/offer/src/test/java/RemoveNthFromEndIITest.java
@@ -0,0 +1,43 @@
+import org.junit.Test;
+
+public class RemoveNthFromEndIITest {
+    RemoveNthFromEndII solver = new RemoveNthFromEndII();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,2,3,4,5};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 2);
+        System.out.println(ListNode.listToArrayList(res));
+        // [1, 2, 3, 5]
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 1);
+        System.out.println(ListNode.listToArrayList(res));
+        // []
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = {1,2};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 1);
+        System.out.println(ListNode.listToArrayList(res));
+        // [1]
+    }
+
+    @Test
+    public void test4() {
+        int[] nums = {1,2};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 2);
+        System.out.println(ListNode.listToArrayList(res));
+        // [2]
+    }
+
+
+}
diff --git a/offer/src/test/java/RemoveNthFromEndTest.java b/offer/src/test/java/RemoveNthFromEndTest.java
new file mode 100644
index 0000000..b12adcd
--- /dev/null
+++ b/offer/src/test/java/RemoveNthFromEndTest.java
@@ -0,0 +1,43 @@
+import org.junit.Test;
+
+public class RemoveNthFromEndTest {
+    RemoveNthFromEnd solver = new RemoveNthFromEnd();
+
+    @Test
+    public void test1() {
+        int[] nums = {1,2,3,4,5};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 2);
+        System.out.println(ListNode.listToArrayList(res));
+        // [1, 2, 3, 5]
+    }
+
+    @Test
+    public void test2() {
+        int[] nums = {1};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 1);
+        System.out.println(ListNode.listToArrayList(res));
+        // []
+    }
+
+    @Test
+    public void test3() {
+        int[] nums = {1,2};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 1);
+        System.out.println(ListNode.listToArrayList(res));
+        // [1]
+    }
+
+    @Test
+    public void test4() {
+        int[] nums = {1,2};
+        ListNode head = ListNode.numToList(nums);
+        ListNode res = solver.removeNthFromEnd(head, 2);
+        System.out.println(ListNode.listToArrayList(res));
+        // [2]
+    }
+
+
+}
diff --git a/offer/src/test/java/SingleNumberTest.java b/offer/src/test/java/SingleNumberTest.java
new file mode 100644
index 0000000..2490a14
--- /dev/null
+++ b/offer/src/test/java/SingleNumberTest.java
@@ -0,0 +1,22 @@
+import org.junit.Test;
+
+public class SingleNumberTest {
+
+    SingleNumber solver = new SingleNumber();
+
+    @Test
+    public void testOne() {
+        int[] nums = {2,2,3,2};
+        int res = solver.singleNumber(nums);
+        System.out.println(res);
+        // 3
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = {0,1,0,1,0,1,100};
+        int res = solver.singleNumber(nums);
+        System.out.println(res);
+        // 100
+    }
+}
diff --git a/offer/src/test/java/StringBuilderTest.java b/offer/src/test/java/StringBuilderTest.java
new file mode 100644
index 0000000..3d7f175
--- /dev/null
+++ b/offer/src/test/java/StringBuilderTest.java
@@ -0,0 +1,19 @@
+import org.junit.Test;
+
+public class StringBuilderTest {
+    StringBuilder solver = new StringBuilder();
+
+    @Test
+    public void testOne() {
+        solver.insert(0, '1');
+        solver.insert(0, '2');
+        System.out.println(solver); // 21
+    }
+
+    @Test
+    public void testTwo() {
+        solver.insert(0, 11);
+        solver.insert(0, 12);
+        System.out.println(solver); // 1211
+    }
+}
diff --git a/offer/src/test/java/SubArraySumTest.java b/offer/src/test/java/SubArraySumTest.java
new file mode 100644
index 0000000..09c7c26
--- /dev/null
+++ b/offer/src/test/java/SubArraySumTest.java
@@ -0,0 +1,24 @@
+import org.junit.Test;
+
+public class SubArraySumTest {
+
+    SubArraySum solver = new SubArraySum();
+
+    @Test
+    public void testOne() {
+        int[] nums = {1, 1, 1};
+        int k = 2;
+        int res = solver.subarraySum(nums, k);
+        System.out.println(res);
+        // 2
+    }
+
+    @Test
+    public void testTwo() {
+        int[] nums = {1, 2, 3};
+        int k = 3;
+        int res = solver.subarraySum(nums, k);
+        System.out.println(res);
+        // 2
+    }
+}
diff --git a/offer/src/test/java/ThreeSumIITest.java b/offer/src/test/java/ThreeSumIITest.java
new file mode 100644
index 0000000..cf1b62b
--- /dev/null
+++ b/offer/src/test/java/ThreeSumIITest.java
@@ -0,0 +1,44 @@
+import org.junit.Test;
+
+import java.util.List;
+
+public class ThreeSumIITest {
+
+    ThreeSumII solver = new ThreeSumII();
+
+    @Test
+    public void testOne() {
+        int[] nums = {-1,0,1,2,-1,-4};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [-1, 2, -1]
+             * [0, 1, -1]
+             */
+        }
+    }
+
+
+    @Test
+    public void testTwo() {
+        int[] nums = {0,1,1};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+
+
+    @Test
+    public void testThree() {
+        int[] nums = {0,0,0};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [0,0,0]
+             */
+        }
+    }
+}
diff --git a/offer/src/test/java/ThreeSumTest.java b/offer/src/test/java/ThreeSumTest.java
new file mode 100644
index 0000000..fe28ef3
--- /dev/null
+++ b/offer/src/test/java/ThreeSumTest.java
@@ -0,0 +1,44 @@
+import org.junit.Test;
+
+import java.util.List;
+
+public class ThreeSumTest {
+
+    ThreeSum solver = new ThreeSum();
+
+    @Test
+    public void testOne() {
+        int[] nums = {-1,0,1,2,-1,-4};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [-1, 2, -1]
+             * [0, 1, -1]
+             */
+        }
+    }
+
+
+    @Test
+    public void testTwo() {
+        int[] nums = {0,1,1};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+        }
+    }
+
+
+    @Test
+    public void testThree() {
+        int[] nums = {0,0,0};
+        List<List<Integer>> res = solver.threeSum(nums);
+        for(List<Integer> t: res) {
+            System.out.println(t);
+            /**
+             * [0,0,0]
+             */
+        }
+    }
+}
diff --git a/offer/src/test/java/TwoIntegerDivide2Test.java b/offer/src/test/java/TwoIntegerDivide2Test.java
new file mode 100644
index 0000000..4851263
--- /dev/null
+++ b/offer/src/test/java/TwoIntegerDivide2Test.java
@@ -0,0 +1,54 @@
+import org.junit.Test;
+
+public class TwoIntegerDivide2Test {
+    TwoIntegerDivide solver = new TwoIntegerDivide();
+
+    @Test
+    public void testOne() {
+        int a=15, b=2;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 7
+    }
+
+    @Test
+    public void testTwo() {
+        int a=7, b=-3;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // -2
+    }
+
+    @Test
+    public void testThree() {
+        int a=0, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 0
+    }
+
+    @Test
+    public void testFour() {
+        int a=1, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testFive() {
+        int a=-2147483648, b=-1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 2147483647
+    }
+
+    @Test
+    public void testSix() {
+        int a=-2147483648, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // -2147483648
+    }
+
+}
diff --git a/offer/src/test/java/TwoIntegerDivideTest.java b/offer/src/test/java/TwoIntegerDivideTest.java
new file mode 100644
index 0000000..7bc9429
--- /dev/null
+++ b/offer/src/test/java/TwoIntegerDivideTest.java
@@ -0,0 +1,54 @@
+import org.junit.Test;
+
+public class TwoIntegerDivideTest {
+    TwoIntegerDivide solver = new TwoIntegerDivide();
+
+    @Test
+    public void testOne() {
+        int a=15, b=2;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 7
+    }
+
+    @Test
+    public void testTwo() {
+        int a=7, b=-3;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // -2
+    }
+
+    @Test
+    public void testThree() {
+        int a=0, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 0
+    }
+
+    @Test
+    public void testFour() {
+        int a=1, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 1
+    }
+
+    @Test
+    public void testFive() {
+        int a=-2147483648, b=-1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // 2147483647
+    }
+
+    @Test
+    public void testSix() {
+        int a=-2147483648, b=1;
+        int res = solver.divide(a, b);
+        System.out.println(res);
+        // -2147483648
+    }
+
+}
diff --git a/offer/src/test/java/TwoSumTes.java b/offer/src/test/java/TwoSumTes.java
new file mode 100644
index 0000000..f8665a3
--- /dev/null
+++ b/offer/src/test/java/TwoSumTes.java
@@ -0,0 +1,2 @@
+public class TwoSumTes {
+}
diff --git a/offer/src/test/java/ValidPalindromeTest.java b/offer/src/test/java/ValidPalindromeTest.java
new file mode 100644
index 0000000..8e07985
--- /dev/null
+++ b/offer/src/test/java/ValidPalindromeTest.java
@@ -0,0 +1,46 @@
+import org.junit.Test;
+
+public class ValidPalindromeTest {
+
+    ValidPalindrome solver = new ValidPalindrome();
+
+    @Test
+    public void test1() {
+        String s = "aba";
+        boolean res = solver.validPalindrome(s);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test2() {
+        String s = "abca";
+        boolean res = solver.validPalindrome(s);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test3() {
+        String s = "abc";
+        boolean res = solver.validPalindrome(s);
+        System.out.println(res);
+        // false
+    }
+
+    @Test
+    public void test4() {
+        String s = "cbbcc";
+        boolean res = solver.validPalindrome(s);
+        System.out.println(res);
+        // true
+    }
+
+    @Test
+    public void test5() {
+        String s = "abc";
+        boolean res = solver.validPalindrome(s);
+        System.out.println(res);
+        // false
+    }
+}
diff --git a/offer/src/test/java/WordMaxProductTest.java b/offer/src/test/java/WordMaxProductTest.java
new file mode 100644
index 0000000..444479b
--- /dev/null
+++ b/offer/src/test/java/WordMaxProductTest.java
@@ -0,0 +1,35 @@
+import org.junit.Test;
+
+public class WordMaxProductTest {
+
+    WordMaxProduct solver = new WordMaxProduct();
+
+    @Test
+    public void testOne() {
+
+        String[] words = {"abcw","baz","foo","bar","fxyz","abcdef"};
+        int res = solver.maxProduct(words);
+        System.out.println(res);
+        // 16
+    }
+
+    @Test
+    public void testTwo() {
+
+        String[] words = {"a","ab","abc","d","cd","bcd","abcd"};
+        int res = solver.maxProduct(words);
+        System.out.println(res);
+        // 4
+    }
+
+    @Test
+    public void testThree() {
+
+        String[] words = {"a","aa","aaa","aaaa"};
+        int res = solver.maxProduct(words);
+        System.out.println(res);
+        // 0
+    }
+
+
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..326f690
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.andy</groupId>
+    <artifactId>andy_leetcode</artifactId>
+    <packaging>pom</packaging>
+    <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <modules>
+        <module>leetcode</module>
+        <module>offer</module>
+        <module>leetcode</module>
+        <module>favorite</module>
+    </modules>
+
+    <dependencies>
+        <dependency>
+            <!--            不区分大小写-->
+            <groupId>JUNIT</groupId>
+            <artifactId>JUNIT</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>JUNIT</groupId>
+            <artifactId>JUNIT</artifactId>
+            <version>4.12</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.7</version>
+        </dependency>
+    </dependencies>
+
+
+</project>
\ No newline at end of file