diff --git a/src/main/java/com/leetcode/array/PossibleRotatedMatrix.java b/src/main/java/com/leetcode/array/PossibleRotatedMatrix.java
new file mode 100644
index 0000000..ed91767
--- /dev/null
+++ b/src/main/java/com/leetcode/array/PossibleRotatedMatrix.java
@@ -0,0 +1,61 @@
+package com.leetcode.array;
+
+final class PossibleRotatedMatrix {
+    private PossibleRotatedMatrix() {
+    }
+
+    static boolean findRotation(int[][] mat, int[][] target) {
+        return isEqual(mat, target) || isFlipped(mat, target)
+                || isTurnedClockwise(mat, target)
+                || isTurnedClockwise(target, mat);
+    }
+
+    private static boolean isEqual(int[][] mat, int[][] target) {
+        int n = mat.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] != target[i][j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private static boolean isFlipped(int[][] mat, int[][] target) {
+        int n = mat.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] != target[n - 1 - i][n - 1 - j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private static boolean isTurnedClockwise(int[][] m, int[][] t) {
+        int n = m.length;
+        int sideSize = n;
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = i; j < sideSize; j++) {
+                if (m[i][j] != t[j][n - 1 - i]) {
+                    return false;
+                }
+                if (m[j][n - 1 - i] != t[n - 1 - i][n - 1 - j]) {
+                    return false;
+                }
+
+                if (m[n - 1 - i][j] != t[j][i]) {
+                    return false;
+                }
+
+                if (m[j][i] != t[i][n - 1 - j]) {
+                    return false;
+                }
+            }
+            sideSize--;
+        }
+        return true;
+    }
+}
diff --git a/src/main/java/com/leetcode/array/SmallestRange2.java b/src/main/java/com/leetcode/array/SmallestRange2.java
new file mode 100644
index 0000000..d929128
--- /dev/null
+++ b/src/main/java/com/leetcode/array/SmallestRange2.java
@@ -0,0 +1,23 @@
+package com.leetcode.array;
+
+import java.util.Arrays;
+
+final class SmallestRange2 {
+    private SmallestRange2() {
+
+    }
+
+    static int smallestRangeII(int[] nums, int k) {
+        Arrays.sort(nums);
+        int bestScore = nums[nums.length - 1] - nums[0];
+        int firstPlus = nums[0] + k;
+        int lastMinus = nums[nums.length - 1] - k;
+        for (int i = 0; i < nums.length - 1; i++) {
+            int lastPlus = nums[i] + k;
+            int firstMinus = nums[i + 1] - k;
+            int score = Math.max(lastPlus, lastMinus) - Math.min(firstMinus, firstPlus);
+            bestScore = Math.min(score, bestScore);
+        }
+        return bestScore;
+    }
+}
diff --git a/src/main/java/com/leetcode/impl/AuthenticationManager.java b/src/main/java/com/leetcode/impl/AuthenticationManager.java
new file mode 100644
index 0000000..9607c22
--- /dev/null
+++ b/src/main/java/com/leetcode/impl/AuthenticationManager.java
@@ -0,0 +1,40 @@
+package com.leetcode.impl;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+final class AuthenticationManager {
+    private final Map<String, Integer> storage;
+    private int timeToLive;
+
+    AuthenticationManager(int timeToLive) {
+        this.timeToLive = timeToLive;
+        this.storage = new HashMap<>();
+    }
+
+    public void generate(String tokenId, int currentTime) {
+        this.storage.putIfAbsent(tokenId, currentTime);
+    }
+
+    public void renew(String tokenId, int currentTime) {
+        Integer tokenStartTime = storage.get(tokenId);
+        if (tokenStartTime != null && tokenStartTime + timeToLive < currentTime) {
+            storage.put(tokenId, currentTime);
+        }
+    }
+
+    public int countUnexpiredTokens(int currentTime) {
+        int count = 0;
+        Iterator<Map.Entry<String, Integer>> it = storage.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, Integer> kv = it.next();
+            if (kv.getValue() + timeToLive <= currentTime) {
+                it.remove();
+            } else {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/src/main/java/com/leetcode/impl/CircularGame.java b/src/main/java/com/leetcode/impl/CircularGame.java
new file mode 100644
index 0000000..b33b0fe
--- /dev/null
+++ b/src/main/java/com/leetcode/impl/CircularGame.java
@@ -0,0 +1,14 @@
+package com.leetcode.impl;
+
+final class CircularGame {
+    private CircularGame() {
+    }
+
+    static int findTheWinner(int n, int k) {
+        if (n == 1) {
+            return 1;
+        } else {
+            return (findTheWinner(n - 1, k) + k - 1) % n;
+        }
+    }
+}
diff --git a/src/main/java/com/leetcode/intervals/InsertInterval.java b/src/main/java/com/leetcode/intervals/InsertInterval.java
new file mode 100644
index 0000000..f494d31
--- /dev/null
+++ b/src/main/java/com/leetcode/intervals/InsertInterval.java
@@ -0,0 +1,55 @@
+package com.leetcode.intervals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+final class InsertInterval {
+    private InsertInterval() {
+    }
+
+    @SuppressWarnings("squid:S3012")
+    static int[][] insert(int[][] intervals, int[] newInterval) {
+        List<int[]> res = new ArrayList<>();
+        int i = 0;
+        while (i < intervals.length && !isOverlap(intervals[i], newInterval)) {
+            res.add(intervals[i]);
+            i++;
+        }
+        if (i == intervals.length) {
+            if (intervals.length == 0) {
+                res.add(newInterval);
+            } else {
+                int j = 0;
+                while (j < intervals.length && intervals[j][0] < newInterval[0]) {
+                    j++;
+                }
+                res.add(j, newInterval);
+            }
+        }
+
+        if (i < intervals.length) {
+            int[] mergedInterval = new int[2];
+            mergedInterval[0] = Math.min(newInterval[0], intervals[i][0]);
+            mergedInterval[1] = Math.max(newInterval[1], intervals[i][1]);
+            i++;
+            while (i < intervals.length && isOverlap(intervals[i], mergedInterval)) {
+                mergedInterval[1] = Math.max(intervals[i][1], mergedInterval[1]);
+                i++;
+            }
+            res.add(mergedInterval);
+        }
+        while (i < intervals.length) {
+            res.add(intervals[i]);
+            i++;
+        }
+        return res.toArray(int[][]::new);
+    }
+
+    private static boolean isOverlap(int[] i1, int[] i2) {
+        if (i1[1] >= i2[0] && i1[1] <= i2[1]) {
+            return true;
+        }
+        return i2[1] >= i1[0] && i2[1] <= i1[1];
+    }
+}
+
diff --git a/src/main/java/com/leetcode/list/MyCircularQueue.java b/src/main/java/com/leetcode/list/MyCircularQueue.java
new file mode 100644
index 0000000..111762e
--- /dev/null
+++ b/src/main/java/com/leetcode/list/MyCircularQueue.java
@@ -0,0 +1,73 @@
+package com.leetcode.list;
+
+final class MyCircularQueue {
+    private final int maxSize;
+    private ListNode head;
+    private ListNode tail;
+    private int size = 0;
+
+    MyCircularQueue(int k) {
+        this.head = null;
+        this.tail = null;
+        this.maxSize = k;
+    }
+
+    public boolean enQueue(int value) {
+        if (!isFull()) {
+            addAtTail(value);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean deQueue() {
+        if (!isEmpty()) {
+            if (head == tail) {
+                head = null;
+                tail = null;
+            } else {
+                head = head.next;
+            }
+            size--;
+            return true;
+        }
+        return false;
+    }
+
+    @SuppressWarnings( {"checkstyle:MethodName", "squid:S100"})
+    public int Front() {
+        if (head != null) {
+            return head.val;
+        }
+        return -1;
+    }
+
+    @SuppressWarnings( {"checkstyle:MethodName", "squid:S100"})
+    public int Rear() {
+        if (tail != null) {
+            return tail.val;
+        }
+        return -1;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public boolean isFull() {
+        return size == maxSize;
+    }
+
+
+    private void addAtTail(int val) {
+        ListNode newNode = new ListNode(val);
+        if (tail == null) {
+            tail = newNode;
+            head = tail;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+}
diff --git a/src/main/java/com/leetcode/list/MyLinkedList.java b/src/main/java/com/leetcode/list/MyLinkedList.java
new file mode 100644
index 0000000..1ea2f3f
--- /dev/null
+++ b/src/main/java/com/leetcode/list/MyLinkedList.java
@@ -0,0 +1,118 @@
+package com.leetcode.list;
+
+final class MyLinkedList {
+    private Node head;
+    private Node tail;
+    private int size = 0;
+
+    MyLinkedList() {
+        this.head = null;
+        this.tail = null;
+    }
+
+    int get(int index) {
+        if (index > -1 && index < size) {
+            Node it = head;
+            int i = 0;
+            while (it != null) {
+                if (i == index) {
+                    return it.val;
+                }
+                i++;
+                it = it.next;
+            }
+        }
+        return -1;
+    }
+
+    public void addAtHead(int val) {
+        Node newNode = new Node(val);
+        if (head == null) {
+            head = newNode;
+            tail = head;
+        } else {
+            newNode.next = head;
+            head = newNode;
+        }
+        size++;
+    }
+
+    public void addAtTail(int val) {
+        Node newNode = new Node(val);
+        if (tail == null) {
+            tail = newNode;
+            head = tail;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    public void addAtIndex(int index, int val) {
+        if (index > 0 && index < size) {
+            Node newNode = new Node(val);
+            int i = 0;
+            Node it = head;
+            while (i < index) {
+                if (i + 1 == index) {
+                    newNode.next = it.next;
+                    it.next = newNode;
+                    size++;
+                    break;
+                }
+                i++;
+                it = it.next;
+            }
+        }
+        if (index == 0) {
+            addAtHead(val);
+        }
+        if (index == size) {
+            addAtTail(val);
+        }
+    }
+
+    public void deleteAtIndex(int index) {
+        if (index > 0 && index < size) {
+            int i = 0;
+            Node it = head;
+            while (i < index) {
+                if (i + 1 == index) {
+                    Node next = it.next;
+                    it.next = next.next;
+                    if (next == tail) {
+                        tail = it;
+                    }
+                    size--;
+                    break;
+                }
+                i++;
+                it = it.next;
+            }
+        }
+        if (index == 0 && size > 0) {
+            removeHead();
+        }
+    }
+
+    private void removeHead() {
+        if (head == tail) {
+            head = null;
+            tail = null;
+        } else {
+            head = head.next;
+        }
+        size--;
+    }
+
+
+    private static final class Node {
+        private final int val;
+        private Node next;
+
+        private Node(int val) {
+            this.val = val;
+        }
+    }
+}
diff --git a/src/main/java/com/leetcode/list/NestedIterator.java b/src/main/java/com/leetcode/list/NestedIterator.java
new file mode 100644
index 0000000..ab72f3d
--- /dev/null
+++ b/src/main/java/com/leetcode/list/NestedIterator.java
@@ -0,0 +1,52 @@
+package com.leetcode.list;
+
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+
+public final class NestedIterator implements Iterator<Integer> {
+    private final Deque<NestedInteger> next = new ArrayDeque<>();
+
+    public NestedIterator(List<NestedInteger> nestedList) {
+        for (NestedInteger integer : nestedList) {
+            if (integer.isInteger() || !integer.getList().isEmpty()) {
+                next.addFirst(integer);
+            }
+        }
+    }
+
+    @Override
+    public Integer next() {
+        if (hasNext()) {
+            return next.removeLast().getInteger();
+        }
+        throw new NoSuchElementException();
+    }
+
+    @Override
+    public boolean hasNext() {
+        while (!next.isEmpty() && !next.peekLast().isInteger()) {
+            NestedInteger integer = next.removeLast();
+            List<NestedInteger> list = integer.getList();
+            for (int i = list.size() - 1; i >= 0; i--) {
+                NestedInteger ni = list.get(i);
+                if (ni.isInteger() || !ni.getList().isEmpty()) {
+                    next.addLast(ni);
+                }
+            }
+        }
+        return !next.isEmpty();
+    }
+
+    interface NestedInteger {
+        boolean isInteger();
+
+        Integer getInteger();
+
+        List<NestedInteger> getList();
+    }
+}
diff --git a/src/main/java/com/leetcode/math/NextGreaterElement3.java b/src/main/java/com/leetcode/math/NextGreaterElement3.java
new file mode 100644
index 0000000..ed0bcaf
--- /dev/null
+++ b/src/main/java/com/leetcode/math/NextGreaterElement3.java
@@ -0,0 +1,60 @@
+package com.leetcode.math;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+final class NextGreaterElement3 {
+
+    private static final int BASE = 10;
+
+    private NextGreaterElement3() {
+    }
+
+    static int nextGreaterElement(int n) {
+        long rest = n / BASE;
+        int lastD = n % BASE;
+        boolean hasGreatest = false;
+        Deque<Integer> deque = new ArrayDeque<>();
+        deque.addLast(lastD);
+        while (rest > 0) {
+            int d = (int) rest % BASE;
+            deque.addLast(d);
+            rest /= BASE;
+            if (d < lastD) {
+                hasGreatest = true;
+                break;
+            }
+            lastD = d;
+        }
+        if (!hasGreatest) {
+            return -1;
+        }
+        Deque<Integer> changedPartOrder = buildChangedPartDigitOrder(deque);
+        while (!changedPartOrder.isEmpty()) {
+            rest = rest * BASE + changedPartOrder.removeFirst();
+        }
+        if (rest > Integer.MAX_VALUE) {
+            return -1;
+        }
+        return (int) rest;
+    }
+
+    private static Deque<Integer> buildChangedPartDigitOrder(Deque<Integer> currentOrder) {
+        Deque<Integer> newOrder = new ArrayDeque<>();
+        int movedDigit = currentOrder.removeLast();
+        while (!currentOrder.isEmpty()) {
+            if (currentOrder.peekLast() > movedDigit) {
+                newOrder.addFirst(currentOrder.removeLast());
+            } else {
+                break;
+            }
+        }
+        int removed = newOrder.removeFirst();
+        newOrder.addFirst(movedDigit);
+        while (!currentOrder.isEmpty()) {
+            newOrder.addFirst(currentOrder.removeLast());
+        }
+        newOrder.addFirst(removed);
+        return newOrder;
+    }
+}
diff --git a/src/main/java/com/leetcode/stack/MinimumRemoveToMakeValidParentheses.java b/src/main/java/com/leetcode/stack/MinimumRemoveToMakeValidParentheses.java
new file mode 100644
index 0000000..8abe596
--- /dev/null
+++ b/src/main/java/com/leetcode/stack/MinimumRemoveToMakeValidParentheses.java
@@ -0,0 +1,49 @@
+package com.leetcode.stack;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Set;
+
+final class MinimumRemoveToMakeValidParentheses {
+    private MinimumRemoveToMakeValidParentheses() {
+    }
+
+    static String minRemoveToMakeValid(String s) {
+        Set<Integer> removedPositions = calcPositionsToRemove(s);
+        char[] res = new char[s.length() - removedPositions.size()];
+        int j = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (!removedPositions.contains(i)) {
+                res[j] = s.charAt(i);
+                j++;
+            }
+        }
+        return new String(res);
+    }
+
+    private static Set<Integer> calcPositionsToRemove(String s) {
+        Deque<Integer> deque = new ArrayDeque<>();
+        int i = 0;
+        Set<Integer> removedPositions = new HashSet<>();
+        while (i < s.length()) {
+            char c = s.charAt(i);
+            if (c == '(' || c == ')') {
+                if (c == '(') {
+                    deque.addLast(i);
+                } else {
+                    if (!deque.isEmpty()) {
+                        deque.removeLast();
+                    } else {
+                        removedPositions.add(i);
+                    }
+                }
+            }
+            i++;
+        }
+        while (!deque.isEmpty()) {
+            removedPositions.add(deque.removeLast());
+        }
+        return removedPositions;
+    }
+}
diff --git a/src/main/java/com/leetcode/stack/NextGreaterElement2.java b/src/main/java/com/leetcode/stack/NextGreaterElement2.java
index f366197..d7e1f07 100644
--- a/src/main/java/com/leetcode/stack/NextGreaterElement2.java
+++ b/src/main/java/com/leetcode/stack/NextGreaterElement2.java
@@ -8,48 +8,40 @@ private NextGreaterElement2() {
     }
 
     public static int[] nextGreaterElements(int[] nums) {
-        Deque<Integer> deque = monotonicStack(nums);
+        Deque<Integer> deque = new ArrayDeque<>();
         int[] res = new int[nums.length];
-        int i = 0;
-        while (!deque.isEmpty()) {
-            if (i == deque.peekFirst()) {
-                deque.removeFirst();
-            }
-            if (!deque.isEmpty()) {
-                res[i] = nums[deque.peekFirst()];
-            } else {
-                res[i] = -1;
-            }
-            i++;
-        }
-        if (i == 0) {
-            res[i] = -1;
-            i++;
-        }
-        for (int j = 0; j < nums.length; j++) {
-            if (nums[j] > nums[nums.length - 1]) {
-                deque.addLast(j);
-                break;
-            }
-        }
-        for (int j = i; j < nums.length; j++) {
+        for (int i = 0; i < nums.length; i++) {
             if (deque.isEmpty()) {
-                res[j] = -1;
+                deque.addLast(i);
             } else {
-                res[j] = nums[deque.peekLast()];
+                if (nums[i] <= nums[deque.peekLast()]) {
+                    deque.addLast(i);
+                } else {
+                    while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
+                        int lessIndex = deque.removeLast();
+                        res[lessIndex] = nums[i];
+                    }
+                    deque.addLast(i);
+                }
             }
         }
+        hadnleUncovered(nums, deque, res);
         return res;
     }
 
-    private static Deque<Integer> monotonicStack(int[] nums) {
-        Deque<Integer> deque = new ArrayDeque<>();
-        for (int i = 0; i < nums.length; i++) {
-            if (deque.isEmpty() || nums[i] > nums[deque.peekLast()]) {
-                deque.addLast(i);
+    private static void hadnleUncovered(int[] nums, Deque<Integer> deque, int[] res) {
+        int i = 0;
+
+        while (!deque.isEmpty()) {
+            while (i < deque.peekLast() && nums[i] <= nums[deque.peekLast()]) {
+                i++;
+            }
+            if (nums[i] == nums[deque.peekLast()]) {
+                res[deque.removeLast()] = -1;
+            } else {
+                res[deque.removeLast()] = nums[i];
             }
         }
-        deque.removeFirst();
-        return deque;
     }
+
 }
diff --git a/src/main/java/com/leetcode/tree/Codec.java b/src/main/java/com/leetcode/tree/Codec.java
new file mode 100644
index 0000000..3f9949d
--- /dev/null
+++ b/src/main/java/com/leetcode/tree/Codec.java
@@ -0,0 +1,93 @@
+package com.leetcode.tree;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+final class Codec {
+
+    private static Integer parseNullableInteger(final String numStr) {
+        if (Objects.equals(numStr, "null")) {
+            return null;
+        }
+        return Integer.parseInt(numStr);
+    }
+
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        LinkedList<TreeNode> deque = new LinkedList<>();
+        StringBuilder sb = new StringBuilder("[");
+        if (root != null) {
+            deque.addFirst(root);
+            sb.append(root.val);
+        }
+        while (!deque.isEmpty()) {
+            int k = deque.size();
+            sb.append(',');
+            for (int i = 0; i < k; i++) {
+                TreeNode node = deque.removeLast();
+                if (node.left != null) {
+                    deque.addFirst(node.left);
+                    sb.append(node.left.val).append(',');
+                } else {
+                    sb.append("null,");
+                }
+                if (node.right != null) {
+                    deque.addFirst(node.right);
+                    sb.append(node.right.val);
+                } else {
+                    sb.append("null");
+                }
+                if (i != k - 1) {
+                    sb.append(',');
+                }
+            }
+        }
+        return sb.append(']').toString();
+    }
+
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        String strList = data.substring(1, data.length() - 1);
+        if (strList.isEmpty()) {
+            return null;
+        }
+        LinkedList<Integer> values = Arrays.stream(strList.split(",\\s*"))
+                .map(Codec::parseNullableInteger)
+                .collect(Collectors.toCollection(LinkedList::new));
+        if (values.isEmpty()) {
+            return null;
+        }
+
+        LinkedList<TreeNode> lastLevel = new LinkedList<>();
+        TreeNode root = new TreeNode(values.removeFirst());
+        lastLevel.add(root);
+        while (!values.isEmpty()) {
+            handleLevel(values, lastLevel);
+        }
+        return root;
+    }
+
+    private void handleLevel(LinkedList<Integer> values, LinkedList<TreeNode> lastLevel) {
+        int k = lastLevel.size();
+        for (int i = 0; i < k; i++) {
+            TreeNode node = lastLevel.removeFirst();
+            if (!values.isEmpty()) {
+                Integer left = values.removeFirst();
+                Integer right = null;
+                if (!values.isEmpty()) {
+                    right = values.removeFirst();
+                }
+                if (left != null) {
+                    node.left = new TreeNode(left);
+                    lastLevel.addLast(node.left);
+                }
+                if (right != null) {
+                    node.right = new TreeNode(right);
+                    lastLevel.addLast(node.right);
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/leetcode/tree/SameTree.java b/src/main/java/com/leetcode/tree/SameTree.java
new file mode 100644
index 0000000..6b26d75
--- /dev/null
+++ b/src/main/java/com/leetcode/tree/SameTree.java
@@ -0,0 +1,16 @@
+package com.leetcode.tree;
+
+final class SameTree {
+    private SameTree() {
+    }
+
+    public static boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == null && q == null) {
+            return true;
+        }
+        if (p == null || q == null) {
+            return false;
+        }
+        return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+    }
+}
diff --git a/src/test/java/com/leetcode/array/PossibleRotatedMatrixTest.java b/src/test/java/com/leetcode/array/PossibleRotatedMatrixTest.java
new file mode 100644
index 0000000..d4b6e5e
--- /dev/null
+++ b/src/test/java/com/leetcode/array/PossibleRotatedMatrixTest.java
@@ -0,0 +1,57 @@
+package com.leetcode.array;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class PossibleRotatedMatrixTest {
+
+    static Stream<Arguments> testCases() {
+        return Stream.of(
+                Arguments.of(new int[][] {
+                                {0, 0, 0}, {0, 1, 0}, {1, 1, 1}
+                        },
+                        new int[][] {
+                                {1, 1, 1}, {0, 1, 0}, {0, 0, 0}
+                        },
+                        true
+                ),
+                Arguments.of(
+                        new int[][] {
+                                {0, 1}, {1, 1}
+                        },
+                        new int[][] {
+                                {1, 0}, {0, 1}
+                        },
+                        false
+                ),
+                Arguments.of(new int[][] {
+                                {0, 0}, {0, 1}
+                        },
+                        new int[][] {
+                                {0, 0}, {1, 0}
+                        },
+                        true
+                ),
+                Arguments.of(new int[][] {
+                                {1, 0, 0}, {0, 0, 0}, {0, 0, 0}
+                        },
+                        new int[][] {
+                                {0, 0, 0}, {0, 0, 0}, {0, 0, 1}
+                        },
+                        true
+                )
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testCases")
+    void findRotation(int[][] mat, int[][] target, boolean expected) {
+        boolean actual = PossibleRotatedMatrix.findRotation(mat, target);
+        assertEquals(expected, actual);
+    }
+}
diff --git a/src/test/java/com/leetcode/array/SmallestRange2Test.java b/src/test/java/com/leetcode/array/SmallestRange2Test.java
new file mode 100644
index 0000000..c1843b5
--- /dev/null
+++ b/src/test/java/com/leetcode/array/SmallestRange2Test.java
@@ -0,0 +1,20 @@
+package com.leetcode.array;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.converter.ConvertWith;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SmallestRange2Test {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "'1',0,0",
+            "'0,10',2,6",
+            "'1,3,6',3,3"
+    })
+    void smallestRangeII(@ConvertWith(IntArrayConverter.class) int[] nums, int k, int expected) {
+        assertEquals(expected, SmallestRange2.smallestRangeII(nums, k));
+    }
+}
diff --git a/src/test/java/com/leetcode/impl/AuthenticationManagerTest.java b/src/test/java/com/leetcode/impl/AuthenticationManagerTest.java
new file mode 100644
index 0000000..19f3856
--- /dev/null
+++ b/src/test/java/com/leetcode/impl/AuthenticationManagerTest.java
@@ -0,0 +1,19 @@
+package com.leetcode.impl;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class AuthenticationManagerTest {
+    @Test
+    void test() {
+        AuthenticationManager manager = new AuthenticationManager(5);
+        manager.renew("aaa", 1);
+        manager.generate("aaa", 2);
+        assertEquals(1, manager.countUnexpiredTokens(6));
+        manager.generate("bbb", 7);
+        manager.renew("aaa", 8);
+        manager.renew("bbb", 10);
+        assertEquals(0, manager.countUnexpiredTokens(15));
+    }
+}
diff --git a/src/test/java/com/leetcode/impl/CircularGameTest.java b/src/test/java/com/leetcode/impl/CircularGameTest.java
new file mode 100644
index 0000000..a608be7
--- /dev/null
+++ b/src/test/java/com/leetcode/impl/CircularGameTest.java
@@ -0,0 +1,18 @@
+package com.leetcode.impl;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class CircularGameTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "5,2,3"
+    })
+    void testFindTheWinner(int n, int k, int expected) {
+        int actual = CircularGame.findTheWinner(n, k);
+        assertEquals(expected, actual);
+    }
+}
diff --git a/src/test/java/com/leetcode/intervals/InsertIntervalTest.java b/src/test/java/com/leetcode/intervals/InsertIntervalTest.java
new file mode 100644
index 0000000..2ec8d45
--- /dev/null
+++ b/src/test/java/com/leetcode/intervals/InsertIntervalTest.java
@@ -0,0 +1,31 @@
+package com.leetcode.intervals;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+class InsertIntervalTest {
+
+    static Stream<Arguments> testCases() {
+        return Stream.of(Arguments.of(new int[][] {
+                                {1, 3}, {6, 9}
+                        },
+                        new int[] {2, 5},
+                        new int[][] {
+                                {1, 5}, {6, 9}
+                        })
+
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testCases")
+    void testInsert(int[][] intervals, int[] newInterval, int[][] expected) {
+        int[][] actual = InsertInterval.insert(intervals, newInterval);
+        assertArrayEquals(expected, actual);
+    }
+}
diff --git a/src/test/java/com/leetcode/list/MyCircularQueueTest.java b/src/test/java/com/leetcode/list/MyCircularQueueTest.java
new file mode 100644
index 0000000..bd34457
--- /dev/null
+++ b/src/test/java/com/leetcode/list/MyCircularQueueTest.java
@@ -0,0 +1,23 @@
+package com.leetcode.list;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MyCircularQueueTest {
+    @Test
+    void test() {
+        MyCircularQueue cQueue = new MyCircularQueue(3);
+        assertTrue(cQueue.enQueue(1));
+        assertTrue(cQueue.enQueue(2));
+        assertTrue(cQueue.enQueue(3));
+        assertFalse(cQueue.enQueue(4));
+        assertEquals(1, cQueue.Front());
+        assertEquals(3, cQueue.Rear());
+        assertTrue(cQueue.deQueue());
+        assertTrue(cQueue.enQueue(4));
+        assertEquals(4, cQueue.Rear());
+    }
+}
diff --git a/src/test/java/com/leetcode/list/MyLinkedListTest.java b/src/test/java/com/leetcode/list/MyLinkedListTest.java
new file mode 100644
index 0000000..6f52f5e
--- /dev/null
+++ b/src/test/java/com/leetcode/list/MyLinkedListTest.java
@@ -0,0 +1,25 @@
+package com.leetcode.list;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MyLinkedListTest {
+    @Test
+    void test() {
+        MyLinkedList list = new MyLinkedList();
+        list.addAtHead(1);
+        assertEquals(1, list.get(0));
+        list.addAtTail(3);
+        assertEquals(3, list.get(1));
+        list.addAtIndex(1, 2);
+        assertEquals(2, list.get(1));
+        list.deleteAtIndex(1);
+        assertEquals(3, list.get(1));
+        list.addAtTail(4);
+        assertEquals(4, list.get(2));
+        list.deleteAtIndex(0);
+        assertEquals(3, list.get(0));
+
+    }
+}
diff --git a/src/test/java/com/leetcode/math/NextGreaterElement3Test.java b/src/test/java/com/leetcode/math/NextGreaterElement3Test.java
new file mode 100644
index 0000000..aececc2
--- /dev/null
+++ b/src/test/java/com/leetcode/math/NextGreaterElement3Test.java
@@ -0,0 +1,22 @@
+package com.leetcode.math;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class NextGreaterElement3Test {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "12,21",
+            "21,-1",
+            "124651,125146",
+            "1246541,1251446",
+            "12465,12546",
+            "5,-1"
+    })
+    void testNextGreaterElement(int n, int expected) {
+        assertEquals(expected, NextGreaterElement3.nextGreaterElement(n));
+    }
+}
diff --git a/src/test/java/com/leetcode/stack/MinimumRemoveToMakeValidParenthesesTest.java b/src/test/java/com/leetcode/stack/MinimumRemoveToMakeValidParenthesesTest.java
new file mode 100644
index 0000000..fdeee62
--- /dev/null
+++ b/src/test/java/com/leetcode/stack/MinimumRemoveToMakeValidParenthesesTest.java
@@ -0,0 +1,19 @@
+package com.leetcode.stack;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class MinimumRemoveToMakeValidParenthesesTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "'lee(t(c)o)de)','lee(t(c)o)de'",
+            "'a)b(c)d','ab(c)d'",
+            "'))((',''"
+    })
+    void testMinRemoveToMakeValid(String s, String expected) {
+        assertEquals(expected, MinimumRemoveToMakeValidParentheses.minRemoveToMakeValid(s));
+    }
+}
diff --git a/src/test/java/com/leetcode/stack/NextGreaterElement2Test.java b/src/test/java/com/leetcode/stack/NextGreaterElement2Test.java
index b4a815b..3853d39 100644
--- a/src/test/java/com/leetcode/stack/NextGreaterElement2Test.java
+++ b/src/test/java/com/leetcode/stack/NextGreaterElement2Test.java
@@ -13,7 +13,9 @@ class NextGreaterElement2Test {
     @CsvSource( {
             "'1,2,3,4,3','2,3,4,-1,4'",
             "'1,2,1','2,-1,2'",
-            "'5,4,3,2,1','-1,5,5,5,5'"
+            "'5,4,3,2,1','-1,5,5,5,5'",
+            "'1,1,1,1,1','-1,-1,-1,-1,-1'",
+            "'1,2,3,2,1','2,3,-1,3,2'"
     })
     void tesNextGreaterElements(@ConvertWith(IntArrayConverter.class) int[] nums,
                                 @ConvertWith(IntArrayConverter.class) int[] expected) {
diff --git a/src/test/java/com/leetcode/tree/CodecTest.java b/src/test/java/com/leetcode/tree/CodecTest.java
new file mode 100644
index 0000000..e91e659
--- /dev/null
+++ b/src/test/java/com/leetcode/tree/CodecTest.java
@@ -0,0 +1,24 @@
+package com.leetcode.tree;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+final class CodecTest {
+    private final Codec codec = new Codec();
+
+    @ParameterizedTest
+    @CsvSource( {
+            "'[1,2,3,null,null,4,5]'",
+            "'[1,2,3,null,null,4,5,6,7]'",
+            "'[4,-7,-3,null,null,-9,-3,9,-7,-4,null,6,null,-6,-6,null,null,0,6,5,null,9,null,null,-1,-4,null,null,null,-2]'",
+            "'[]'"
+    })
+    void test(String treeString) {
+        TreeNode root = codec.deserialize(treeString);
+        String s = codec.serialize(root);
+        TreeNode des = codec.deserialize(s);
+        assertTrue(SameTree.isSameTree(root, des));
+    }
+}