deque = new LinkedList<>();
+
+ public BSTIterator(TreeNode root) {
+ this.root = root;
+ TreeNode temp = root;
+ // 找最左的子结点，并且将经过的路径都记录下来
+ while (temp != null) {
+ deque.addLast(temp);
+ temp = temp.left;
+ }
+ }
+
+ /**
+ * @return the next smallest number
+ */
+ public int next() {
+
+ if (deque.isEmpty()) {
+ throw new NoSuchElementException();
+ }
+
+ TreeNode temp = deque.removeLast();
+
+ if (temp.right != null) {
+ TreeNode n = temp.right;
+ while (n != null) {
+ deque.addLast(n);
+ n = n.left;
+ }
+ }
+
+ return temp.val;
+ }
+
+ /**
+ * @return whether we have a next smallest number
+ */
+ public boolean hasNext() {
+ return !deque.isEmpty();
+ }
+}
diff --git a/[0173][Binary Search Tree Iterator]/src/Solution.java b/[0173][Binary Search Tree Iterator]/src/Solution.java
new file mode 100644
index 0000000..6fb2141
--- /dev/null
+++ b/[0173][Binary Search Tree Iterator]/src/Solution.java
@@ -0,0 +1,49 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 17:06
+ **/
+public class Solution {
+ @Test
+ public void test1() {
+ TreeNode root = new TreeNode(7);
+ root.left = new TreeNode(3);
+ root.right = new TreeNode(15);
+ root.right.left = new TreeNode(9);
+ root.right.right = new TreeNode(20);
+
+ BSTIterator iterator = new BSTIterator(root);
+ Assert.assertEquals(3, iterator.next()); // return 3
+ Assert.assertEquals(7, iterator.next()); // return 7
+ Assert.assertEquals(true, iterator.hasNext()); // return true
+ Assert.assertEquals(9, iterator.next()); // return 9
+ Assert.assertEquals(true, iterator.hasNext()); // return true
+ Assert.assertEquals(15, iterator.next()); // return 15
+ Assert.assertEquals(true, iterator.hasNext()); // return true
+ Assert.assertEquals(20, iterator.next()); // return 20
+ Assert.assertEquals(false, iterator.hasNext()); // return false
+ }
+
+ @Test
+ public void test2() {
+ TreeNode root = new TreeNode(7);
+ BSTIterator iterator = new BSTIterator(root);
+ Assert.assertEquals(7, iterator.next()); // return 3
+ Assert.assertEquals(false, iterator.hasNext()); // return false
+ Assert.assertEquals(false, iterator.hasNext()); // return false
+ }
+
+ @Test
+ public void test3() {
+ TreeNode root = new TreeNode(1);
+ root.right = new TreeNode(2);
+ BSTIterator iterator = new BSTIterator(root);
+ Assert.assertEquals(true, iterator.hasNext()); // return 3
+ Assert.assertEquals(1, iterator.next()); // return 3
+ Assert.assertEquals(true, iterator.hasNext()); // return false
+ Assert.assertEquals(2, iterator.next()); // return false
+ Assert.assertEquals(false, iterator.hasNext()); // return false
+ }
+}
diff --git a/[0173][Binary Search Tree Iterator]/src/TreeNode.java b/[0173][Binary Search Tree Iterator]/src/TreeNode.java
new file mode 100644
index 0000000..9aec4dd
--- /dev/null
+++ b/[0173][Binary Search Tree Iterator]/src/TreeNode.java
@@ -0,0 +1,15 @@
+/**
+ * Author:
+ * Date: 2015-08-19
+ * Time: 06:45
+ * Declaration: All Rights Reserved !!!
+ */
+public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0191][Number Of 1 Bits]/[0191][Number Of 1 Bits].iml b/[0191][Number Of 1 Bits]/[0191][Number Of 1 Bits].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0191][Number Of 1 Bits]/[0191][Number Of 1 Bits].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0191][Number Of 1 Bits]/[0191][NumberOf1Bits].iml b/[0191][Number Of 1 Bits]/[0191][NumberOf1Bits].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0191][Number Of 1 Bits]/[0191][NumberOf1Bits].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220191\343\200\221\343\200\220NumberOf1Bits\343\200\221/src/Main.java" b/[0191][Number Of 1 Bits]/src/Main.java
similarity index 100%
rename from "\343\200\220191\343\200\221\343\200\220NumberOf1Bits\343\200\221/src/Main.java"
rename to [0191][Number Of 1 Bits]/src/Main.java
diff --git a/[0191][Number Of 1 Bits]/src/Solution.java b/[0191][Number Of 1 Bits]/src/Solution.java
new file mode 100644
index 0000000..3e63a99
--- /dev/null
+++ b/[0191][Number Of 1 Bits]/src/Solution.java
@@ -0,0 +1,30 @@
+/**
+ * Author: ������
+ * Date: 2015-06-17
+ * Time: 21:51
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ * Write a function that takes an unsigned integer and returns the number of ��1' bits it has
+ * (also known as the Hamming weight).
+ *
+ * For example, the 32-bit integer ��11' has binary representation 00000000000000000000000000001011,
+ * so the function should return 3.
+ *
+ * ���������е�λ��
+ *
+ * @param n
+ * @return
+ */
+ // you need to treat n as an unsigned value
+ public int hammingWeight(int n) {
+
+ int count = 0;
+ while (n != 0) {
+ count++;
+ n = (n - 1) & n;
+ }
+ return count;
+ }
+}
diff --git a/[0198][House Robber]/[0198][House Robber].iml b/[0198][House Robber]/[0198][House Robber].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0198][House Robber]/[0198][House Robber].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0198][House Robber]/[0198][HouseRobber].iml b/[0198][House Robber]/[0198][HouseRobber].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0198][House Robber]/[0198][HouseRobber].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220198\343\200\221\343\200\220HouseRobber\343\200\221/src/Main.java" b/[0198][House Robber]/src/Main.java
similarity index 100%
rename from "\343\200\220198\343\200\221\343\200\220HouseRobber\343\200\221/src/Main.java"
rename to [0198][House Robber]/src/Main.java
diff --git "a/\343\200\220198\343\200\221\343\200\220HouseRobber\343\200\221/src/Solution.java" b/[0198][House Robber]/src/Solution.java
similarity index 100%
rename from "\343\200\220198\343\200\221\343\200\220HouseRobber\343\200\221/src/Solution.java"
rename to [0198][House Robber]/src/Solution.java
diff --git a/[0199][Binary Tree Right Side View]/[0199][Binary Tree Right Side View].iml b/[0199][Binary Tree Right Side View]/[0199][Binary Tree Right Side View].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0199][Binary Tree Right Side View]/[0199][Binary Tree Right Side View].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0199][Binary Tree Right Side View]/[0199][BinaryTreeRightSideView].iml b/[0199][Binary Tree Right Side View]/[0199][BinaryTreeRightSideView].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0199][Binary Tree Right Side View]/[0199][BinaryTreeRightSideView].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220199\343\200\221\343\200\220BinaryTreeRightSideView\343\200\221/src/Solution.java" b/[0199][Binary Tree Right Side View]/src/Solution.java
similarity index 100%
rename from "\343\200\220199\343\200\221\343\200\220BinaryTreeRightSideView\343\200\221/src/Solution.java"
rename to [0199][Binary Tree Right Side View]/src/Solution.java
diff --git "a/\343\200\220199\343\200\221\343\200\220BinaryTreeRightSideView\343\200\221/src/TreeNode.java" b/[0199][Binary Tree Right Side View]/src/TreeNode.java
similarity index 100%
rename from "\343\200\220199\343\200\221\343\200\220BinaryTreeRightSideView\343\200\221/src/TreeNode.java"
rename to [0199][Binary Tree Right Side View]/src/TreeNode.java
diff --git a/[0200][Number Of Islands]/[0200][Number Of Islands].iml b/[0200][Number Of Islands]/[0200][Number Of Islands].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0200][Number Of Islands]/[0200][Number Of Islands].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0200][Number Of Islands]/[0200][NumberOfIslands].iml b/[0200][Number Of Islands]/[0200][NumberOfIslands].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0200][Number Of Islands]/[0200][NumberOfIslands].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0200][Number Of Islands]/src/Solution.java b/[0200][Number Of Islands]/src/Solution.java
new file mode 100644
index 0000000..ff8698a
--- /dev/null
+++ b/[0200][Number Of Islands]/src/Solution.java
@@ -0,0 +1,90 @@
+/**
+ * Author: ������
+ * Date: 2015-06-20
+ * Time: 11:00
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ *
+ * Given a 2d grid map of '1's (land) and '0's (water), count the number of islands.
+ * An island is surrounded by water and is formed by connecting adjacent lands horizontally
+ * or vertically. You may assume all four edges of the grid are all surrounded by water.
+ *
+ * Example 1:
+ * 11110
+ * 11010
+ * 11000
+ * 00000
+ * Answer: 1
+ *
+ * Example 2:
+ * 11000
+ * 11000
+ * 00100
+ * 00011
+ * Answer: 3
+ *
+ * ��Ŀ���⣺
+ * ������һ����ά����ĵ�ͼ��'1'��½�أ���0��ˮ�����������������������������滷ˮ��
+ * �������ڵ�½��ˮƽ��ֱ���Ӷ��γɵġ�����Լ��������������ĸ��߶���ˮ��Χ��
+ *
+ * ����˼·��
+ * һ��������һ����Ӧ�ķ��ʱ�Ǿ�������ÿ��Ԫ��ʱ�й�����ȱ���������������ȱ�������ͳ�Ƶ�����Ŀ
+ *
+ *
+ *
+ * @param grid
+ * @return
+ */
+ public int numIslands(char[][] grid) {
+ // ������
+ if (grid == null || grid.length == 0 || grid[0].length == 0) {
+ return 0;
+ }
+
+ // Ԫ��Ĭ��ֵ��false
+ boolean[][] visited = new boolean[grid.length][grid[0].length];
+
+ int result = 0;
+ for (int i = 0; i < grid.length; i++) {
+ for (int j = 0; j < grid[0].length; j++) {
+ // �����λ��û�б����ʹ������Ҵ�λ���ǵ�������¹�����ȱ���
+ if (!visited[i][j] && grid[i][j] == '1') {
+ result++;
+ bfs(grid, visited, i, j);
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * �����������
+ *
+ * @param grid ����
+ * @param visited ���ʱ�Ǿ���
+ * @param row ������
+ * @param col ������
+ */
+ private void bfs(char[][] grid, boolean[][] visited, int row, int col) {
+
+ if (row >= 0 && row < grid.length // �кϷ�
+ && col >= 0 && col < grid[0].length // �кϷ�
+ && !visited[row][col] // û�з��ʹ�
+ && grid[row][col] == '1') { // �ǵ���½��
+
+ // ��Ǵ�λ���Ѿ����ʹ���
+ visited[row][col] = true;
+
+ // ��
+ bfs(grid, visited, row - 1, col);
+ // ��
+ bfs(grid, visited, row, col + 1);
+ // ��
+ bfs(grid, visited, row + 1, col);
+ // ��
+ bfs(grid, visited, row, col - 1);
+ }
+ }
+}
diff --git a/[0201][Bitwise AND Of Numbers Range]/[0201][Bitwise AND Of Numbers Range].iml b/[0201][Bitwise AND Of Numbers Range]/[0201][Bitwise AND Of Numbers Range].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0201][Bitwise AND Of Numbers Range]/[0201][Bitwise AND Of Numbers Range].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0201][Bitwise AND Of Numbers Range]/[0201][BitwiseANDOfNumbersRange].iml b/[0201][Bitwise AND Of Numbers Range]/[0201][BitwiseANDOfNumbersRange].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0201][Bitwise AND Of Numbers Range]/[0201][BitwiseANDOfNumbersRange].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220201\343\200\221\343\200\220BitwiseANDOfNumbersRange\343\200\221/src/Solution.java" b/[0201][Bitwise AND Of Numbers Range]/src/Solution.java
similarity index 100%
rename from "\343\200\220201\343\200\221\343\200\220BitwiseANDOfNumbersRange\343\200\221/src/Solution.java"
rename to [0201][Bitwise AND Of Numbers Range]/src/Solution.java
diff --git a/[0202][Happy Number ]/[0202][Happy Number ].iml b/[0202][Happy Number ]/[0202][Happy Number ].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0202][Happy Number ]/[0202][Happy Number ].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0202][Happy Number ]/[0202][HappyNumber ].iml b/[0202][Happy Number ]/[0202][HappyNumber ].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0202][Happy Number ]/[0202][HappyNumber ].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220202\343\200\221\343\200\220HappyNumber \343\200\221/src/Main.java" b/[0202][Happy Number ]/src/Main.java
similarity index 100%
rename from "\343\200\220202\343\200\221\343\200\220HappyNumber \343\200\221/src/Main.java"
rename to [0202][Happy Number ]/src/Main.java
diff --git a/[0202][Happy Number ]/src/Solution.java b/[0202][Happy Number ]/src/Solution.java
new file mode 100644
index 0000000..46f562d
--- /dev/null
+++ b/[0202][Happy Number ]/src/Solution.java
@@ -0,0 +1,51 @@
+import java.util.HashSet;
+
+/**
+ * Author: ������
+ * Date: 2015-06-17
+ * Time: 21:36
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ * Write an algorithm to determine if a number is "happy".
+ * A happy number is a number defined by the following process: Starting with any positive integer,
+ * replace the number by the sum of the squares of its digits, and repeat the process until the number
+ * equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1. Those
+ * numbers for which this process ends in 1 are happy numbers.
+ *
+ * ��ĿҪ�������һ�������������ϸ�����λ�����ֵ�ƽ���ͣ�����������Ϊ1���������Ϊhappy number��
+ * ���������ܴ�ij������ʼ����ѭ����
+ *
+ * @param n
+ * @return
+ */
+ public boolean isHappy(int n) {
+
+ if (n < 1) {
+ return false;
+ }
+
+ // ���ڱ����м���ֵĽ��
+ HashSet set = new HashSet<>(32);
+
+ int tmp;
+ int newN;
+
+ // n��Ϊ1������n��ֵ�����ظ����֣��������ѭ��
+ while (n != 1 && !set.contains(n)) {
+ set.add(n);
+ newN = 0;
+ while (n > 0) {
+ tmp = n % 10;
+ n /= 10;
+ newN += tmp * tmp;
+ }
+
+ n = newN;
+ }
+
+ return n == 1;
+ }
+
+}
diff --git a/[0203][Remove Linked List Elements]/[0203][Remove Linked List Elements].iml b/[0203][Remove Linked List Elements]/[0203][Remove Linked List Elements].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0203][Remove Linked List Elements]/[0203][Remove Linked List Elements].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0203][Remove Linked List Elements]/[0203][RemoveLinkedList Elements].iml b/[0203][Remove Linked List Elements]/[0203][RemoveLinkedList Elements].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0203][Remove Linked List Elements]/[0203][RemoveLinkedList Elements].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220203\343\200\221\343\200\220RemoveLinkedList Elements\343\200\221/src/ListNode.java" b/[0203][Remove Linked List Elements]/src/ListNode.java
similarity index 100%
rename from "\343\200\220203\343\200\221\343\200\220RemoveLinkedList Elements\343\200\221/src/ListNode.java"
rename to [0203][Remove Linked List Elements]/src/ListNode.java
diff --git "a/\343\200\220203\343\200\221\343\200\220RemoveLinkedList Elements\343\200\221/src/Solution.java" b/[0203][Remove Linked List Elements]/src/Solution.java
similarity index 100%
rename from "\343\200\220203\343\200\221\343\200\220RemoveLinkedList Elements\343\200\221/src/Solution.java"
rename to [0203][Remove Linked List Elements]/src/Solution.java
diff --git a/[0204][Count Primes]/[0204][Count Primes].iml b/[0204][Count Primes]/[0204][Count Primes].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0204][Count Primes]/[0204][Count Primes].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0204][Count Primes]/[0204][CountPrimes].iml b/[0204][Count Primes]/[0204][CountPrimes].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0204][Count Primes]/[0204][CountPrimes].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220204\343\200\221\343\200\220CountPrimes\343\200\221/src/Solution.java" b/[0204][Count Primes]/src/Solution.java
similarity index 100%
rename from "\343\200\220204\343\200\221\343\200\220CountPrimes\343\200\221/src/Solution.java"
rename to [0204][Count Primes]/src/Solution.java
diff --git a/[0205][Isomorphic Strings]/[0205][Isomorphic Strings].iml b/[0205][Isomorphic Strings]/[0205][Isomorphic Strings].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0205][Isomorphic Strings]/[0205][Isomorphic Strings].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0205][Isomorphic Strings]/[0205][IsomorphicStrings].iml b/[0205][Isomorphic Strings]/[0205][IsomorphicStrings].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0205][Isomorphic Strings]/[0205][IsomorphicStrings].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220205\343\200\221\343\200\220IsomorphicStrings\343\200\221/src/Solution.java" b/[0205][Isomorphic Strings]/src/Solution.java
similarity index 100%
rename from "\343\200\220205\343\200\221\343\200\220IsomorphicStrings\343\200\221/src/Solution.java"
rename to [0205][Isomorphic Strings]/src/Solution.java
diff --git a/[0206][Reverse Linked List]/[0206][Reverse Linked List].iml b/[0206][Reverse Linked List]/[0206][Reverse Linked List].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0206][Reverse Linked List]/[0206][Reverse Linked List].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220206\343\200\221\343\200\220ReverseLinkedList\343\200\221/src/ListNode.java" b/[0206][Reverse Linked List]/src/ListNode.java
similarity index 100%
rename from "\343\200\220206\343\200\221\343\200\220ReverseLinkedList\343\200\221/src/ListNode.java"
rename to [0206][Reverse Linked List]/src/ListNode.java
diff --git "a/\343\200\220206\343\200\221\343\200\220ReverseLinkedList\343\200\221/src/Main.java" b/[0206][Reverse Linked List]/src/Main.java
similarity index 100%
rename from "\343\200\220206\343\200\221\343\200\220ReverseLinkedList\343\200\221/src/Main.java"
rename to [0206][Reverse Linked List]/src/Main.java
diff --git a/[0206][Reverse Linked List]/src/Solution.java b/[0206][Reverse Linked List]/src/Solution.java
new file mode 100644
index 0000000..360bebd
--- /dev/null
+++ b/[0206][Reverse Linked List]/src/Solution.java
@@ -0,0 +1,48 @@
+/**
+ * Author:
+ * Date: 2015-06-19
+ * Time: 11:17
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ * Reverse a singly linked list.
+ * ת
+ * ʹͷ巨
+ *
+ * @param head
+ * @return
+ */
+ public ListNode reverseList(ListNode head) {
+ // ͷ
+ ListNode root = new ListNode(0);
+ ListNode nextNode;
+ while (head != null) {
+ nextNode = head.next;
+ head.next = root.next;
+ root.next = head;
+ head = nextNode;
+ }
+
+ head = root.next;
+ root.next = null;
+
+ return head;
+ }
+
+ /**
+ * TODO ʹõݹⷨ
+ *
+ * @param head
+ * @return
+ */
+ public ListNode reverseList2(ListNode head) {
+ if (head == null) {
+ return null;
+ }
+
+ reverseList2(head.next).next = head;
+
+ return null;
+ }
+}
diff --git a/[0207][Course Schedule]/[0207][Course Schedule].iml b/[0207][Course Schedule]/[0207][Course Schedule].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0207][Course Schedule]/[0207][Course Schedule].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0207][Course Schedule]/src/Main.java b/[0207][Course Schedule]/src/Main.java
new file mode 100644
index 0000000..a94abab
--- /dev/null
+++ b/[0207][Course Schedule]/src/Main.java
@@ -0,0 +1,45 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-07 11:35
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ int[][] arr = {{1, 0}};
+ Assert.assertEquals(true, solution.canFinish(2, arr));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ int[][] arr = {{1, 0}, {0, 1}};
+ Assert.assertEquals(false, solution.canFinish(2, arr));
+ }
+
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ int[][] arr = {{0, 1}, {0, 2}, {1, 2}};
+ Assert.assertEquals(true, solution.canFinish(3, arr));
+ }
+
+ @Test
+ public void test4() {
+ Solution solution = new Solution();
+ int[][] arr = {{2, 0}, {1, 0}, {3, 1}, {3, 2}, {1, 3}};
+ Assert.assertEquals(false, solution.canFinish(4, arr));
+ }
+
+
+ @Test
+ public void test5() {
+ Solution solution = new Solution();
+ int[][] arr = {{1, 0}, {2, 6}, {1, 7}, {6, 4}, {7, 0}, {0, 5}};
+ Assert.assertEquals(true, solution.canFinish(8, arr));
+ }
+}
diff --git a/[0207][Course Schedule]/src/Solution.java b/[0207][Course Schedule]/src/Solution.java
new file mode 100644
index 0000000..208c49e
--- /dev/null
+++ b/[0207][Course Schedule]/src/Solution.java
@@ -0,0 +1,104 @@
+import java.util.*;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-07 11:23
+ **/
+public class Solution {
+ /**
+ *
+ * There are a total of n courses you have to take, labeled from 0 to n-1.
+ *
+ * Some courses may have prerequisites, for example to take course 0 you have to first take
+ * course 1, which is expressed as a pair: [0,1]
+ *
+ * Given the total number of courses and a list of prerequisite pairs, is it possible for
+ * you to finish all courses?
+ *
+ * Example 1:
+ *
+ * Input: 2, [[1,0]]
+ * Output: true
+ * Explanation: There are a total of 2 courses to take.
+ * To take course 1 you should have finished course 0. So it is possible.
+ * Example 2:
+ *
+ * Input: 2, [[1,0],[0,1]]
+ * Output: false
+ * Explanation: There are a total of 2 courses to take.
+ * To take course 1 you should have finished course 0, and to take course 0 you should
+ * also have finished course 1. So it is impossible.
+ * Note:
+ *
+ * The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read
+ * more about how a graph is represented.
+ * You may assume that there are no duplicate edges in the input prerequisites.
+ *
+ * 解题思路：
+ * 使用深度度优先遍历，记录每个访问过的点，如果遍历过程中再次遍历到了已经访问过的点，
+ * 说明有环状依赖，课程安排不合理
+ *
+ */
+
+ public boolean canFinish(int numCourses, int[][] prerequisites) {
+ // 说明没有课程依赖
+ if (prerequisites == null || prerequisites.length == 0) {
+ return true;
+ }
+
+
+ Map> dependencies = new HashMap<>();
+
+ for (int[] arr : prerequisites) {
+ List val = dependencies.computeIfAbsent(arr[0], k -> new LinkedList<>());
+ val.add(arr[1]);
+ }
+
+ boolean[] visit = new boolean[numCourses];
+ Deque path = new LinkedList<>();
+ for (int i = 0; i < visit.length; i++) {
+ if (!visit[i]) {
+ if (!dfs(i, dependencies, visit, path)) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * 判断从i课程序开始，是否存在环
+ *
+ * @param course
+ * @param dependencies
+ * @param visit
+ * @return
+ */
+ private boolean dfs(int course, Map> dependencies, boolean[] visit, Deque path) {
+ List dependency = dependencies.get(course);
+
+ if (dependency == null) {
+ return true;
+ }
+
+ if (path.contains(course)) {
+ return false;
+ }
+
+ path.addLast(course);
+
+
+ for (int i : dependency) {
+ boolean result = dfs(i, dependencies, visit, path);
+ if (!result) {
+ return false;
+ }
+ }
+
+ visit[course] = true;
+ path.removeLast();
+
+ return true;
+ }
+}
diff --git a/[0215][Kth Largest Element In An Array]/[0215][Kth Largest Element In An Array].iml b/[0215][Kth Largest Element In An Array]/[0215][Kth Largest Element In An Array].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0215][Kth Largest Element In An Array]/[0215][Kth Largest Element In An Array].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0215][Kth Largest Element In An Array]/[0215][KthLargestElementInAnArray].iml b/[0215][Kth Largest Element In An Array]/[0215][KthLargestElementInAnArray].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0215][Kth Largest Element In An Array]/[0215][KthLargestElementInAnArray].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0215][Kth Largest Element In An Array]/src/Main.java b/[0215][Kth Largest Element In An Array]/src/Main.java
new file mode 100644
index 0000000..ec1a203
--- /dev/null
+++ b/[0215][Kth Largest Element In An Array]/src/Main.java
@@ -0,0 +1,12 @@
+/**
+ * Author: ������
+ * Date: 2015-06-19
+ * Time: 20:01
+ * Declaration: All Rights Reserved !!!
+ */
+public class Main {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+ System.out.println(solution.findKthLargest(new int[]{2, 1}, 2));
+ }
+}
diff --git a/[0215][Kth Largest Element In An Array]/src/Solution.java b/[0215][Kth Largest Element In An Array]/src/Solution.java
new file mode 100644
index 0000000..7648127
--- /dev/null
+++ b/[0215][Kth Largest Element In An Array]/src/Solution.java
@@ -0,0 +1,79 @@
+/**
+ * Author: ������
+ * Date: 2015-06-19
+ * Time: 19:36
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ *
+ * Find the kth largest element in an unsorted array. Note that it is the kth
+ * largest element in the sorted order, not the kth distinct element.
+ *
+ * For example,
+ * Given [3,2,1,5,6,4] and k = 2, return 5.
+ *
+ * Note:
+ * You may assume k is always valid, 1 �� k �� array's length.
+ *
+ * ��Ŀ���⣺
+ * ��һ��δ��������������ҳ���k���Ԫ�ء�ע��������֮��ĵ�k���ǵ�k�����ظ���Ԫ��
+ * ���Լ���kһ������Ч�ģ� 1 �� k �� ���鳤��
+ *
+ * ����˼·��
+ * O(n)�ⷨ������ѡ��QuickSelect���㷨
+ *
+ *
+ * @param nums
+ * @param k
+ * @return
+ */
+ public int findKthLargest(int[] nums, int k) {
+
+ if (k < 1 || nums == null || nums.length < k) {
+ throw new IllegalArgumentException();
+ }
+
+ return findKthLargest(nums, 0, nums.length - 1, k);
+ }
+
+ public int findKthLargest(int[] nums, int start, int end, int k) {
+
+ // ����ֵ
+ int pivot = nums[start];
+ int lo = start;
+ int hi = end;
+
+ while (lo < hi) {
+ // ��С������ֵ�����ƶ����������
+ while (lo < hi && nums[hi] >= pivot) {
+ hi--;
+ }
+ nums[lo] = nums[hi];
+
+ // ����������ֵ�����ƶ��������ұ�
+ while (lo < hi && nums[lo] <= pivot) {
+ lo++;
+ }
+ nums[hi] = nums[lo];
+ }
+
+ nums[lo] = pivot;
+
+ // ����Ѿ��ҵ���
+ if (end - lo + 1 == k) {
+ return pivot;
+ }
+ // ��k�������loλ�õ��ұ�
+ else if (end - lo + 1 > k) {
+ return findKthLargest(nums, lo + 1, end, k);
+ }
+ // ��k�������loλ�õ����
+ else {
+ // k-(end-lo+1)
+ // (end-lo+1)����ʾ��loλ�ÿ�ʼ��endλ�õ�Ԫ�ظ�������������Ұ벿��
+ // ԭ���ĵ�k����k-(end-lo+1)��
+ return findKthLargest(nums, start, lo - 1, k - (end - lo + 1));
+ }
+ }
+}
diff --git a/[0216][Combination Sum III]/[0216][Combination Sum III].iml b/[0216][Combination Sum III]/[0216][Combination Sum III].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0216][Combination Sum III]/[0216][Combination Sum III].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0216][Combination Sum III]/[0216][CombinationSumIII].iml b/[0216][Combination Sum III]/[0216][CombinationSumIII].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0216][Combination Sum III]/[0216][CombinationSumIII].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220216\343\200\221\343\200\220CombinationSumIII\343\200\221/src/Main.java" b/[0216][Combination Sum III]/src/Main.java
similarity index 100%
rename from "\343\200\220216\343\200\221\343\200\220CombinationSumIII\343\200\221/src/Main.java"
rename to [0216][Combination Sum III]/src/Main.java
diff --git a/[0216][Combination Sum III]/src/Solution.java b/[0216][Combination Sum III]/src/Solution.java
new file mode 100644
index 0000000..563a5f7
--- /dev/null
+++ b/[0216][Combination Sum III]/src/Solution.java
@@ -0,0 +1,100 @@
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Author: ������
+ * Date: 2015-06-21
+ * Time: 21:31
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ /**
+ *
+ * Find all possible combinations of k numbers that add up to a number n,
+ * given that only numbers from 1 to 9 can be used and each combination
+ * should be a unique set of numbers.
+ *
+ * Ensure that numbers within the set are sorted in ascending order.
+ *
+ * Example 1:
+ * Input: k = 3, n = 7
+ * Output:
+ * [[1,2,4]]
+ *
+ * Example 2:
+ * Input: k = 3, n = 9
+ * Output:
+ * [[1,2,6], [1,3,5], [2,3,4]]
+ *
+ * ��Ŀ���⣺
+ * Ѱ����������k����֮�͵���n����ϣ�ֻ����ʹ������1-9������ÿһ������е�����Ӧ����Ψһ�ġ�
+ * ȷ������е������Ե���˳�����С�
+ *
+ * ����˼·��
+ * ���ݷ�
+ *
+ *
+ * @param k
+ * @param n
+ * @return
+ */
+ public List> combinationSum3(int k, int n) {
+ // ���ڱ������н��
+ List> result = new LinkedList<>();
+ // ���ڱ����м���
+ List list = new LinkedList<>();
+ // ��������ͽ��н������
+ if (k > 0 && k <= 9) {
+ solve(k, 1, n, 0, list, result);
+ }
+
+ // ���ؽ��
+ return result;
+ }
+
+ /**
+ * ��ⷽ��
+ *
+ * @param k ÿ�����Ԫ�ظ���
+ * @param cur ��ǰ�����k��Ԫ��
+ * @param remainder k - cur + 1��Ԫ�صĺ�
+ * @param prevVal ��cur-1��Ԫ�ص�ȡֵ
+ * @param list �����Ԫ�صļ�����
+ * @param result ��������������
+ */
+ public void solve(int k, int cur, int remainder, int prevVal, List list, List> result) {
+ // �������һ��Ԫ��
+ if (cur == k) {
+ // remainderΪ���һ����Ԫ�ص�ֵ�����������ǰһ����Ԫ�ص�ֵ�����Ҳ��ܳ���9
+ if (remainder > prevVal && remainder <= 9) {
+ // ���Ԫ��ֵ
+ list.add(remainder);
+
+ // ����������µĶ�����
+ List one = new LinkedList<>();
+ for (Integer i : list) {
+ one.add(i);
+ }
+
+ // ������
+ result.add(one);
+ // ɾ�����һ��Ԫ�أ������ֳ���ԭ
+ list.remove(list.size() - 1);
+ }
+ }
+ // �������һ��Ԫ��
+ else if (cur < k) {
+ for (int i = prevVal + 1; i <= 9 - (k - cur); i++) {
+ // ���Ԫ��
+ list.add(i);
+ // �ݹ����
+ solve(k, cur + 1, remainder - i, i, list, result);
+ // �ֳ���ԭ
+ list.remove(list.size() - 1);
+
+ }
+ }
+
+
+ }
+}
diff --git a/[0217][Contains Duplicate ]/[0217][Contains Duplicate ].iml b/[0217][Contains Duplicate ]/[0217][Contains Duplicate ].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0217][Contains Duplicate ]/[0217][Contains Duplicate ].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0217][Contains Duplicate ]/[0217][ContainsDuplicate ].iml b/[0217][Contains Duplicate ]/[0217][ContainsDuplicate ].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0217][Contains Duplicate ]/[0217][ContainsDuplicate ].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220217\343\200\221\343\200\220ContainsDuplicate \343\200\221/src/Main.java" b/[0217][Contains Duplicate ]/src/Main.java
similarity index 100%
rename from "\343\200\220217\343\200\221\343\200\220ContainsDuplicate \343\200\221/src/Main.java"
rename to [0217][Contains Duplicate ]/src/Main.java
diff --git a/[0217][Contains Duplicate ]/src/Solution.java b/[0217][Contains Duplicate ]/src/Solution.java
new file mode 100644
index 0000000..d144b96
--- /dev/null
+++ b/[0217][Contains Duplicate ]/src/Solution.java
@@ -0,0 +1,46 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Author: ������
+ * Date: 2015-06-18
+ * Time: 09:40
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+
+
+ /**
+ * Given an array of integers, find if the array contains any duplicates.
+ * Your function should return true if any value appears at least twice in the
+ * array, and it should return false if every element is distinct.
+ *
+ * ��Ŀ���⣺����һ���������飬�ж��������Ƿ�����ظ�Ԫ�ء��������������һ�����ֳ������������Σ�
+ * ��ĺ���Ӧ�÷���true�����ÿһ��Ԫ�ض���Ψһ�ģ�����false��
+ *
+ * ����˼·����set���ݽṹ
+ *
+ * @param nums
+ * @return
+ */
+ public boolean containsDuplicate(int[] nums) {
+
+ // Ԫ�ظ�������1�Ž�������IJ���
+ if (nums != null && nums.length > 1) {
+ //����һ��hashSet
+ Set set = new HashSet<>(nums.length);
+ for (int i : nums) {
+ // ���Ԫ���Ѿ����ھͷ���true
+ if (set.contains(i)) {
+ return true;
+ }
+ // û�о���ӵ�Ԫ�ؼ�����
+ else {
+ set.add(i);
+ }
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/[0219][Contains Duplicate II]/[0219][Contains Duplicate II].iml b/[0219][Contains Duplicate II]/[0219][Contains Duplicate II].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0219][Contains Duplicate II]/[0219][Contains Duplicate II].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0219][Contains Duplicate II]/[0219][ContainsDuplicateII].iml b/[0219][Contains Duplicate II]/[0219][ContainsDuplicateII].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0219][Contains Duplicate II]/[0219][ContainsDuplicateII].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0219][Contains Duplicate II]/src/Solution.java b/[0219][Contains Duplicate II]/src/Solution.java
new file mode 100644
index 0000000..3c0f97e
--- /dev/null
+++ b/[0219][Contains Duplicate II]/src/Solution.java
@@ -0,0 +1,55 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Author: ������
+ * Date: 2015-06-19
+ * Time: 14:10
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+
+ /**
+ * Given an array of integers and an integer k, find out whether there there are
+ * two distinct indices i and j in the array such that nums[i] = nums[j] and the
+ * difference between i and j is at most k.
+ *
+ * ��Ŀ���⣺
+ * ����һ����������nums��һ������k�����ҽ�������������ͬ���±�i��j����nums[i] = nums[j]
+ * ����|i-j|<=kʱ����true������false��
+ *
+ * ����˼·��
+ * ��nums[0...n-1]������һ��map�У�(muns[i], i)�������nums[k]�Ѿ����ڣ�
+ * ��Ƚ�֮ǰ���±�����ڵ��±�IJ�ֵ�������ֵ������k��˵��������������������ֵ��
+ * ����ʹ���µ��±���Ϊֵ
+ *
+ * @param nums
+ * @param k
+ * @return
+ */
+ public boolean containsNearbyDuplicate(int[] nums, int k) {
+ // ���������ж�
+ if (nums == null || nums.length < 2 || k < 1) {
+ return false;
+ }
+
+ Map map = new HashMap<>();
+ for (int i = 0; i < nums.length; i++) {
+
+ // ���û�ж�Ӧ��key��ӽ�ȥ
+ if (!map.containsKey(nums[i])) {
+ map.put(nums[i], i);
+ }
+ // �Ѿ��ж�Ӧ��key-value��
+ else {
+ // ԭ�������ֵ��Ӧ���±꣬��һ��С�����ڵ��±�
+ int value = map.get(nums[i]);
+ if (i - value <= k) {
+ return true;
+ }
+ map.put(nums[i], i);
+ }
+ }
+ return false;
+ }
+}
diff --git a/[0222][Count Complete Tree Nodes]/[0222][Count Complete Tree Nodes].iml b/[0222][Count Complete Tree Nodes]/[0222][Count Complete Tree Nodes].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0222][Count Complete Tree Nodes]/[0222][Count Complete Tree Nodes].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0222][Count Complete Tree Nodes]/src/Main.java b/[0222][Count Complete Tree Nodes]/src/Main.java
new file mode 100644
index 0000000..19fccc0
--- /dev/null
+++ b/[0222][Count Complete Tree Nodes]/src/Main.java
@@ -0,0 +1,21 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-08 21:07
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ TreeNode root = new TreeNode(1);
+ root.left = new TreeNode(2);
+ root.right = new TreeNode(3);
+ root.left.left = new TreeNode(4);
+ root.left.right = new TreeNode(5);
+ root.right.left = new TreeNode(6);
+ Solution solution = new Solution();
+
+ Assert.assertEquals(6, solution.countNodes(root));
+ }
+}
diff --git a/[0222][Count Complete Tree Nodes]/src/Solution.java b/[0222][Count Complete Tree Nodes]/src/Solution.java
new file mode 100644
index 0000000..ce53173
--- /dev/null
+++ b/[0222][Count Complete Tree Nodes]/src/Solution.java
@@ -0,0 +1,46 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-08 20:52
+ **/
+public class Solution {
+ public int countNodes(TreeNode root) {
+ if (root == null) {
+ return 0;
+ }
+
+ int h1 = leftestHeight(root);
+ int h2 = rightestHeight(root);
+
+ if (h1 == h2) {
+ return ((1 << h1) - 1);
+ }
+
+ return 1 + countNodes(root.left) + countNodes(root.right);
+ }
+
+ /**
+ * 最右路径的长度
+ *
+ * @param node
+ * @return
+ */
+ private int rightestHeight(TreeNode node) {
+ if (node == null) {
+ return 0;
+ }
+ return 1 + rightestHeight(node.right);
+ }
+
+ /**
+ * 最左路径的长度
+ *
+ * @param node
+ * @return
+ */
+ private int leftestHeight(TreeNode node) {
+ if (node == null) {
+ return 0;
+ }
+ return 1 + leftestHeight(node.left);
+ }
+}
diff --git "a/\343\200\220226\343\200\221\343\200\220InvertBinaryTree \343\200\221/src/TreeNode.java" b/[0222][Count Complete Tree Nodes]/src/TreeNode.java
similarity index 100%
rename from "\343\200\220226\343\200\221\343\200\220InvertBinaryTree \343\200\221/src/TreeNode.java"
rename to [0222][Count Complete Tree Nodes]/src/TreeNode.java
diff --git a/[0223][Rectangle Area]/[0223][Rectangle Area].iml b/[0223][Rectangle Area]/[0223][Rectangle Area].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0223][Rectangle Area]/[0223][Rectangle Area].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0223][Rectangle Area]/[0223][RectangleArea].iml b/[0223][Rectangle Area]/[0223][RectangleArea].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0223][Rectangle Area]/[0223][RectangleArea].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220223\343\200\221\343\200\220RectangleArea\343\200\221/src/Main.java" b/[0223][Rectangle Area]/src/Main.java
similarity index 100%
rename from "\343\200\220223\343\200\221\343\200\220RectangleArea\343\200\221/src/Main.java"
rename to [0223][Rectangle Area]/src/Main.java
diff --git a/[0223][Rectangle Area]/src/Solution.java b/[0223][Rectangle Area]/src/Solution.java
new file mode 100644
index 0000000..b8d05d5
--- /dev/null
+++ b/[0223][Rectangle Area]/src/Solution.java
@@ -0,0 +1,76 @@
+/**
+ * Author: ������
+ * Date: 2015-06-19
+ * Time: 15:32
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+
+ /**
+ *
+ * Find the total area covered by two rectilinear rectangles in a 2D plane.
+ * Each rectangle is defined by its bottom left corner and top right
+ * corner as shown in the figure.
+ *
+ * Assume that the total area is never beyond the maximum possible value of int.
+ *
+ * *****************************(C,D):(3,4)
+ * * *
+ * * *
+ * * *************************************(G,H):(9,2)
+ * * * * *
+ * * * * *
+ * * * * *
+ * * * * *
+ * * *(0,0) * *
+ * ***************************** *
+ * (A,B):(-3,0)* *
+ * * *
+ * * (E,F):(0��-1) *
+ * *************************************
+ *
+ * *************************** ***************************
+ * * D * * H *
+ * * * * *
+ * *A C* *E G*
+ * * * * *
+ * * * * *
+ * * B * * F *
+ * *************************** ***************************
+ *
+ *
+ *
+ *
+ * ��Ŀ���⣺
+ * �������������ܹ����ǵ����
+ *
+ * ����˼·��
+ * ���㷽��Ϊ����1�����+����2�����-�������ι�ͬ�ĸ��������
+ *
+ * @param A
+ * @param B
+ * @param C
+ * @param D
+ * @param E
+ * @param F
+ * @param G
+ * @param H
+ * @return
+ */
+ public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) {
+ long area = (long) (C - A) * (D - B) + (long) (G - E) * (H - F);
+ // Math.min(C, G) ��ʾ�ұ߱ߵ���С�ı�
+ // Math.max(A, E) ��ʾ��߱ߵ����ı�
+ // ����ļ������������Խ�飬Ҫ�������ݷ�Χ
+ long width = Math.max((long) Math.min(C, G) - (long) Math.max(A, E), 0);
+ // Math.min(D, H) ��ʾ���߱ߵ���С�ı�
+ // Math.max(B, F) ��ʾ�ױ߱ߵ����ı�
+ long height = Math.max((long) Math.min(D, H) - (long) Math.max(B, F), 0);
+
+ System.out.println(width + ":" + height + "=" + width * height);
+
+ return (int) (area - width * height);
+ }
+
+
+}
diff --git a/[0225][Implement Stack Using Queues]/[0225][Implement Stack Using Queues].iml b/[0225][Implement Stack Using Queues]/[0225][Implement Stack Using Queues].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0225][Implement Stack Using Queues]/[0225][Implement Stack Using Queues].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0225][Implement Stack Using Queues]/[0225][ImplementStackUsingQueues].iml b/[0225][Implement Stack Using Queues]/[0225][ImplementStackUsingQueues].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0225][Implement Stack Using Queues]/[0225][ImplementStackUsingQueues].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220225\343\200\221\343\200\220ImplementStackUsingQueues\343\200\221/src/MyStack.java" b/[0225][Implement Stack Using Queues]/src/MyStack.java
similarity index 100%
rename from "\343\200\220225\343\200\221\343\200\220ImplementStackUsingQueues\343\200\221/src/MyStack.java"
rename to [0225][Implement Stack Using Queues]/src/MyStack.java
diff --git a/[0226][Invert Binary Tree]/[0226][Invert Binary Tree].iml b/[0226][Invert Binary Tree]/[0226][Invert Binary Tree].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0226][Invert Binary Tree]/[0226][Invert Binary Tree].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220226\343\200\221\343\200\220InvertBinaryTree \343\200\221/src/Solution.java" b/[0226][Invert Binary Tree]/src/Solution.java
similarity index 100%
rename from "\343\200\220226\343\200\221\343\200\220InvertBinaryTree \343\200\221/src/Solution.java"
rename to [0226][Invert Binary Tree]/src/Solution.java
diff --git a/[0226][Invert Binary Tree]/src/TreeNode.java b/[0226][Invert Binary Tree]/src/TreeNode.java
new file mode 100644
index 0000000..73c7ed9
--- /dev/null
+++ b/[0226][Invert Binary Tree]/src/TreeNode.java
@@ -0,0 +1,15 @@
+/**
+ * Author:
+ * Date: 2015-06-18
+ * Time: 10:02
+ * Declaration: All Rights Reserved !!!
+ */
+public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0227][Basic Calculator II]/[0227][Basic Calculator II].iml b/[0227][Basic Calculator II]/[0227][Basic Calculator II].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0227][Basic Calculator II]/[0227][Basic Calculator II].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0227][Basic Calculator II]/src/Main.java b/[0227][Basic Calculator II]/src/Main.java
new file mode 100644
index 0000000..9d0983f
--- /dev/null
+++ b/[0227][Basic Calculator II]/src/Main.java
@@ -0,0 +1,32 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-10 13:23
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(7, solution.calculate("3+2*2"));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(5, solution.calculate(" 3 + 5 / 2 "));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ Assert.assertEquals(1, solution.calculate("1-1+1"));
+ }
+
+ @Test
+ public void test4() {
+ Solution solution = new Solution();
+ Assert.assertEquals(1, solution.calculate("1+1-1"));
+ }
+}
diff --git a/[0227][Basic Calculator II]/src/Solution.java b/[0227][Basic Calculator II]/src/Solution.java
new file mode 100644
index 0000000..5f8a945
--- /dev/null
+++ b/[0227][Basic Calculator II]/src/Solution.java
@@ -0,0 +1,133 @@
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * https://leetcode.com/problems/basic-calculator-ii/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-10 10:54
+ **/
+public class Solution {
+ /**
+ *
+ * Implement a basic calculator to evaluate a simple expression string.
+ *
+ * The expression string contains only non-negative integers, +, -, *, / operators
+ * and empty spaces . The integer division should truncate toward zero.
+ *
+ * Example 1:
+ *
+ * Input: "3+2*2"
+ * Output: 7
+ * Example 2:
+ *
+ * Input: " 3/2 "
+ * Output: 1
+ * Example 3:
+ *
+ * Input: " 3+5 / 2 "
+ * Output: 5
+ * Note:
+ *
+ * You may assume that the given expression is always valid.
+ * Do not use the eval built-in library function.
+ * 思路：
+ * 遇到加减就入操作数栈和操作符栈，遇到乘除就计算，将计算结果作为新的字符串的第一个值，后面是处理的字符串
+ * 最后处理所有剩下的加减操作
+ * 如 1+2+3*4+5+6
+ * 处理完第一个*号后
+ * operator: +, +
+ * operand: 1, 2
+ * s: 12+5+6
+ * 整个字符串处理完后
+ * operator: +, +, +, +
+ * operand: 1, 2, 12, 5, 6
+ * 再进行计算
+ *
+ *
+ * @param s
+ * @return
+ */
+ public int calculate(String s) {
+
+ if (s == null || s.length() < 1) {
+ throw new IllegalArgumentException("s: " + s);
+ }
+
+ Deque operands = new LinkedList<>();
+ Deque operators = new LinkedList<>();
+
+ int idx = 0;
+ while (idx < s.length()) {
+ while (idx < s.length() && s.charAt(idx) == ' ') {
+ idx++;
+ }
+
+ // 找操作数
+ int start = idx;
+ idx++;
+ while (idx < s.length() && Character.isDigit(s.charAt(idx))) {
+ idx++;
+ }
+ // 操作数入栈
+ operands.addLast(Integer.parseInt(s.substring(start, idx)));
+
+ // 找idx后的第一个非空白字符
+ while (idx < s.length() && s.charAt(idx) == ' ') {
+ idx++;
+ }
+
+ // 如果是乘法或者除法，就进行一次计算
+ if (idx < s.length() && (s.charAt(idx) == '*' || s.charAt(idx) == '/')) {
+ char op = s.charAt(idx);
+ // 下一个数字的第一个位置
+ while (idx < s.length() && !Character.isDigit(s.charAt(idx))) {
+ idx++;
+ }
+
+ start = idx;
+ while (idx < s.length() && Character.isDigit(s.charAt(idx))) {
+ idx++;
+ }
+
+ int operand = Integer.parseInt(s.substring(start, idx));
+ int prev = operands.removeLast();
+ int result = calculate(prev, operand, op);
+ // 计算结果放在新的字符串首位，idx变成第一位
+ // 比如 1*2+3 => 2+3
+ s = result + s.substring(idx);
+ idx = 0;
+ } else if (idx < s.length() && (s.charAt(idx) == '+' || s.charAt(idx) == '-')) {
+ // 如果是加减
+ operators.addLast(s.charAt(idx));
+ idx++;
+ } else {
+ idx++;
+ }
+ }
+
+ while (!operators.isEmpty()) {
+ int a = operands.removeFirst();
+ int b = operands.removeFirst();
+ int r = calculate(a, b, operators.removeFirst());
+ operands.addFirst(r);
+ }
+
+ return operands.getLast();
+ }
+
+ private int calculate(int a, int b, char op) {
+ switch (op) {
+ case '+':
+ return a + b;
+ case '-':
+ return a - b;
+ case '*':
+ return a * b;
+ case '/':
+ return a / b;
+ default:
+ return 0;
+ }
+ }
+}
diff --git a/[0228][Summary Ranges]/[0228][Summary Ranges].iml b/[0228][Summary Ranges]/[0228][Summary Ranges].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0228][Summary Ranges]/[0228][Summary Ranges].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0228][Summary Ranges]/src/Main.java b/[0228][Summary Ranges]/src/Main.java
new file mode 100644
index 0000000..528c00e
--- /dev/null
+++ b/[0228][Summary Ranges]/src/Main.java
@@ -0,0 +1,24 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-10 13:47
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ int[] arr = {0, 1, 2, 4, 5, 7};
+ Assert.assertEquals(Arrays.asList("0->2", "4->5", "7"), solution.summaryRanges(arr));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ int[] arr = {0, 2, 3, 4, 6, 8, 9};
+ Assert.assertEquals(Arrays.asList("0", "2->4", "6", "8->9"), solution.summaryRanges(arr));
+ }
+}
diff --git a/[0228][Summary Ranges]/src/Solution.java b/[0228][Summary Ranges]/src/Solution.java
new file mode 100644
index 0000000..3fceab0
--- /dev/null
+++ b/[0228][Summary Ranges]/src/Solution.java
@@ -0,0 +1,37 @@
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-10 13:41
+ **/
+public class Solution {
+ public List summaryRanges(int[] nums) {
+ List result = new LinkedList<>();
+
+ if (nums == null || nums.length < 1) {
+ return result;
+ }
+
+ int idx = 0;
+
+ while (idx < nums.length) {
+ int temp = idx;
+ String s = String.valueOf(nums[idx]);
+ idx++;
+ // 找第一个不连续的下标
+ while (idx < nums.length && nums[idx - 1] + 1 == nums[idx]) {
+ idx++;
+ }
+
+ // 判断是否连续
+ if (temp < idx - 1) {
+ result.add(s + "->" + nums[idx - 1]);
+ } else {
+ result.add(s);
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/[0230][Kth Smallest Element in a BST]/[0230][Kth Smallest Element in a BST].iml b/[0230][Kth Smallest Element in a BST]/[0230][Kth Smallest Element in a BST].iml
new file mode 100644
index 0000000..e62ca95
--- /dev/null
+++ b/[0230][Kth Smallest Element in a BST]/[0230][Kth Smallest Element in a BST].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0230][Kth Smallest Element in a BST]/src/Main.java b/[0230][Kth Smallest Element in a BST]/src/Main.java
new file mode 100644
index 0000000..2ad78c0
--- /dev/null
+++ b/[0230][Kth Smallest Element in a BST]/src/Main.java
@@ -0,0 +1,21 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-01 17:42
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ TreeNode root = new TreeNode(3);
+ root.left = new TreeNode(1);
+ root.left.right = new TreeNode(2);
+ root.right = new TreeNode(4);
+ Solution solution = new Solution();
+ Assert.assertEquals(1, solution.kthSmallest(root, 1));
+ Assert.assertEquals(2, solution.kthSmallest(root, 2));
+ Assert.assertEquals(3, solution.kthSmallest(root, 3));
+ Assert.assertEquals(4, solution.kthSmallest(root, 4));
+ }
+}
diff --git a/[0230][Kth Smallest Element in a BST]/src/Solution.java b/[0230][Kth Smallest Element in a BST]/src/Solution.java
new file mode 100644
index 0000000..134eff2
--- /dev/null
+++ b/[0230][Kth Smallest Element in a BST]/src/Solution.java
@@ -0,0 +1,37 @@
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+
+public class Solution {
+
+ public int kthSmallest(TreeNode root, int k) {
+
+ int count = 0;
+ Deque deque = new LinkedList<>();
+
+ deque.addLast(root);
+ // 用于记录下一个需要开始遍历的结点
+ TreeNode node = root;
+ while (node != null || !deque.isEmpty()) {
+ // 找最左节点
+ while (node != null) {
+ deque.addLast(node);
+ node = node.left;
+ }
+
+ // 如果还有结点，就出栈
+ if (!deque.isEmpty()) {
+ node = deque.removeLast();
+ count++;
+ if (count == k) {
+ return node.val;
+ }
+
+ // 记录下一个待处理的节点
+ node = node.right;
+ }
+ }
+
+ throw new NoSuchElementException();
+ }
+}
\ No newline at end of file
diff --git a/[0230][Kth Smallest Element in a BST]/src/TreeNode.java b/[0230][Kth Smallest Element in a BST]/src/TreeNode.java
new file mode 100644
index 0000000..73c7ed9
--- /dev/null
+++ b/[0230][Kth Smallest Element in a BST]/src/TreeNode.java
@@ -0,0 +1,15 @@
+/**
+ * Author:
+ * Date: 2015-06-18
+ * Time: 10:02
+ * Declaration: All Rights Reserved !!!
+ */
+public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0231][Power of Two]/[0231][Power of Two].iml b/[0231][Power of Two]/[0231][Power of Two].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0231][Power of Two]/[0231][Power of Two].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220231\343\200\221\343\200\220Power of Two\343\200\221/src/Solution.java" b/[0231][Power of Two]/src/Solution.java
similarity index 100%
rename from "\343\200\220231\343\200\221\343\200\220Power of Two\343\200\221/src/Solution.java"
rename to [0231][Power of Two]/src/Solution.java
diff --git "a/\343\200\220231\343\200\221\343\200\220Power of Two\343\200\221/src/Test.java" b/[0231][Power of Two]/src/Test.java
similarity index 100%
rename from "\343\200\220231\343\200\221\343\200\220Power of Two\343\200\221/src/Test.java"
rename to [0231][Power of Two]/src/Test.java
diff --git a/[0232][Implement Queue using Stacks]/[0232][Implement Queue using Stacks].iml b/[0232][Implement Queue using Stacks]/[0232][Implement Queue using Stacks].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0232][Implement Queue using Stacks]/[0232][Implement Queue using Stacks].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220232\343\200\221\343\200\220Implement Queue using Stacks\343\200\221/src/MyQueue.java" b/[0232][Implement Queue using Stacks]/src/MyQueue.java
similarity index 94%
rename from "\343\200\220232\343\200\221\343\200\220Implement Queue using Stacks\343\200\221/src/MyQueue.java"
rename to [0232][Implement Queue using Stacks]/src/MyQueue.java
index a4cdc0c..25f2f3c 100644
--- "a/\343\200\220232\343\200\221\343\200\220Implement Queue using Stacks\343\200\221/src/MyQueue.java"
+++ b/[0232][Implement Queue using Stacks]/src/MyQueue.java
@@ -1,6 +1,5 @@
import java.util.LinkedList;
import java.util.List;
-import java.util.Queue;
/**
* @author: wangjunchao(王俊超)
@@ -8,7 +7,7 @@
**/
class MyQueue {
- private List list;
+ private List list;
/**
* Initialize your data structure here.
diff --git "a/\343\200\220232\343\200\221\343\200\220Implement Queue using Stacks\343\200\221/src/Test.java" b/[0232][Implement Queue using Stacks]/src/Test.java
similarity index 100%
rename from "\343\200\220232\343\200\221\343\200\220Implement Queue using Stacks\343\200\221/src/Test.java"
rename to [0232][Implement Queue using Stacks]/src/Test.java
diff --git a/[0234][Palindrome Linked List]/[0234][Palindrome Linked List].iml b/[0234][Palindrome Linked List]/[0234][Palindrome Linked List].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0234][Palindrome Linked List]/[0234][Palindrome Linked List].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0234][Palindrome Linked List]/src/ListNode.java b/[0234][Palindrome Linked List]/src/ListNode.java
new file mode 100644
index 0000000..4d4fcb5
--- /dev/null
+++ b/[0234][Palindrome Linked List]/src/ListNode.java
@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:03
+ **/
+public class ListNode {
+ int val;
+ ListNode next;
+
+ ListNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0234][Palindrome Linked List]/src/Solution.java b/[0234][Palindrome Linked List]/src/Solution.java
new file mode 100644
index 0000000..65ba7ea
--- /dev/null
+++ b/[0234][Palindrome Linked List]/src/Solution.java
@@ -0,0 +1,58 @@
+/**
+ * O(n) time and O(1) space
+ *
+ * 1->2->2->1
+ * 1->2->3->2->1
+ * 先找到第二个2的位置，将2及后面的链逆转，形成新的链A，再按A与原来的链，从头开开始比较
+ *
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:02
+ **/
+public class Solution {
+ public boolean isPalindrome(ListNode head) {
+
+ // 没有节点或者只有一个结点
+ if (head == null || head.next == null) {
+ return true;
+ }
+
+ int count = 0;
+ ListNode node = head;
+ while (node != null) {
+ count++;
+ node = node.next;
+ }
+
+ // 找反向链的起始位置
+ count = (count + 1) / 2;
+ node = head;
+ while (count > 0) {
+ count--;
+ node = node.next;
+ }
+
+
+ ListNode reverseHead = new ListNode(0);
+ ListNode temp;
+ while (node != null) {
+ temp = node.next;
+ node.next = reverseHead.next;
+ reverseHead.next = node;
+ node = temp;
+ }
+
+ reverseHead = reverseHead.next;
+
+ while (reverseHead != null) {
+ if (head.val != reverseHead.val) {
+ return false;
+ }
+
+ reverseHead = reverseHead.next;
+ head = head.next;
+ }
+
+ return true;
+ }
+}
diff --git "a/\343\200\220234\343\200\221\343\200\220Palindrome Linked List\343\200\221/src/Solution2.java" b/[0234][Palindrome Linked List]/src/Solution2.java
similarity index 100%
rename from "\343\200\220234\343\200\221\343\200\220Palindrome Linked List\343\200\221/src/Solution2.java"
rename to [0234][Palindrome Linked List]/src/Solution2.java
diff --git a/[0234][Palindrome Linked List]/src/Test.java b/[0234][Palindrome Linked List]/src/Test.java
new file mode 100644
index 0000000..28f5ec5
--- /dev/null
+++ b/[0234][Palindrome Linked List]/src/Test.java
@@ -0,0 +1,42 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:10
+ **/
+public class Test {
+ public static void main(String[] args) {
+ test1();
+ test2();
+ test3();
+ }
+
+ public static void test1() {
+ Solution solution = new Solution();
+ ListNode head = new ListNode(1);
+ head.next = new ListNode(2);
+ System.out.println(solution.isPalindrome(head));
+ }
+
+ public static void test2() {
+ Solution solution = new Solution();
+
+ ListNode head = new ListNode(1);
+ head.next = new ListNode(2);
+ head.next.next = new ListNode(2);
+ head.next.next.next = new ListNode(1);
+ head.next.next.next.next = new ListNode(2);
+ head.next.next.next.next.next = new ListNode(2);
+ head.next.next.next.next.next.next = new ListNode(1);
+ System.out.println(solution.isPalindrome(head));
+ }
+
+ public static void test3() {
+ Solution solution = new Solution();
+
+ ListNode head = new ListNode(1);
+ head.next = new ListNode(2);
+ head.next.next = new ListNode(2);
+ head.next.next.next = new ListNode(1);
+
+ System.out.println(solution.isPalindrome(head));
+ }
+}
diff --git a/[0235][Lowest Common Ancestor of a Binary Search Tree]/[0235][Lowest Common Ancestor of a Binary Search Tree].iml b/[0235][Lowest Common Ancestor of a Binary Search Tree]/[0235][Lowest Common Ancestor of a Binary Search Tree].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0235][Lowest Common Ancestor of a Binary Search Tree]/[0235][Lowest Common Ancestor of a Binary Search Tree].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220235\343\200\221\343\200\220Lowest Common Ancestor of a Binary Search Tree\343\200\221/src/Solution.java" b/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/Solution.java
similarity index 100%
rename from "\343\200\220235\343\200\221\343\200\220Lowest Common Ancestor of a Binary Search Tree\343\200\221/src/Solution.java"
rename to [0235][Lowest Common Ancestor of a Binary Search Tree]/src/Solution.java
diff --git a/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/TreeNode.java b/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/TreeNode.java
new file mode 100644
index 0000000..141d430
--- /dev/null
+++ b/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/TreeNode.java
@@ -0,0 +1,13 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:33
+ **/
+public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0237][Delete Node in a Linked List]/[0237][Delete Node in a Linked List].iml b/[0237][Delete Node in a Linked List]/[0237][Delete Node in a Linked List].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0237][Delete Node in a Linked List]/[0237][Delete Node in a Linked List].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0237][Delete Node in a Linked List]/src/ListNode.java b/[0237][Delete Node in a Linked List]/src/ListNode.java
new file mode 100644
index 0000000..9e0f1da
--- /dev/null
+++ b/[0237][Delete Node in a Linked List]/src/ListNode.java
@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 09:58
+ **/
+public class ListNode {
+ int val;
+ ListNode next;
+
+ ListNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0237][Delete Node in a Linked List]/src/Solution.java b/[0237][Delete Node in a Linked List]/src/Solution.java
new file mode 100644
index 0000000..6c60753
--- /dev/null
+++ b/[0237][Delete Node in a Linked List]/src/Solution.java
@@ -0,0 +1,32 @@
+/**
+ *
+ * Definition for singly-linked list.
+ * public class ListNode {
+ * int val;
+ * ListNode next;
+ * ListNode(int x) { val = x; }
+ * }
+ *
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 09:57
+ **/
+class Solution {
+ public void deleteNode(ListNode node) {
+
+ if (node == null || node.next == null) {
+ return;
+ }
+
+ ListNode prev = node;
+ while (node.next != null) {
+ node.val = node.next.val;
+ prev = node;
+ node = node.next;
+
+
+ }
+
+ prev.next = null;
+ }
+}
\ No newline at end of file
diff --git a/[0237][Delete Node in a Linked List]/src/Test.java b/[0237][Delete Node in a Linked List]/src/Test.java
new file mode 100644
index 0000000..a6ee290
--- /dev/null
+++ b/[0237][Delete Node in a Linked List]/src/Test.java
@@ -0,0 +1,32 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 10:01
+ **/
+public class Test {
+ public static void main(String[] args) {
+ ListNode node = new ListNode(4);
+ node.next = new ListNode(5);
+ node.next.next = new ListNode(1);
+ node.next.next.next = new ListNode(9);
+
+ Solution solution = new Solution();
+ solution.deleteNode(node.next);
+
+ print(node);
+ }
+
+ private static void print(ListNode node) {
+ do {
+ if (node == null) {
+ System.out.println("null");
+ } else if (node.next != null) {
+ System.out.print(node.val + "->");
+ node = node.next;
+ } else {
+ System.out.println(node.val + "->null");
+ node = node.next;
+ }
+
+ } while (node != null);
+ }
+}
diff --git a/[0238][Product of Array Except Self]/[0238][Product of Array Except Self].iml b/[0238][Product of Array Except Self]/[0238][Product of Array Except Self].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0238][Product of Array Except Self]/[0238][Product of Array Except Self].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0238][Product of Array Except Self]/src/Main.java b/[0238][Product of Array Except Self]/src/Main.java
new file mode 100644
index 0000000..b2097c4
--- /dev/null
+++ b/[0238][Product of Array Except Self]/src/Main.java
@@ -0,0 +1,26 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 14:31
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertArrayEquals(new int[]{24, 12, 8, 6}, solution.productExceptSelf(new int[]{1, 2, 3, 4}));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertArrayEquals(new int[]{0, 0}, solution.productExceptSelf(new int[]{0, 0}));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ Assert.assertArrayEquals(new int[]{1, 0}, solution.productExceptSelf(new int[]{0, 1}));
+ }
+}
diff --git a/[0238][Product of Array Except Self]/src/Solution.java b/[0238][Product of Array Except Self]/src/Solution.java
new file mode 100644
index 0000000..e0c6b32
--- /dev/null
+++ b/[0238][Product of Array Except Self]/src/Solution.java
@@ -0,0 +1,71 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 14:29
+ **/
+public class Solution {
+ /**
+ *
+ * Given an array nums of n integers where n > 1,
+ * return an array output such that output[i] is equal to the product of all the
+ * elements of nums except nums[i].
+ *
+ * Example:
+ *
+ * Input: [1,2,3,4]
+ * Output: [24,12,8,6]
+ * Note: Please solve it without division and in O(n).
+ *
+ * Follow up:
+ * Could you solve it with constant space complexity? (The output array does not count as
+ * extra space for the purpose of space complexity analysis.)
+ *
+ *
+ * @param nums
+ * @return
+ */
+ public int[] productExceptSelf(int[] nums) {
+ int[] result = new int[nums.length];
+
+ // 记录为0的下票
+ Set zero = new HashSet<>();
+
+
+ long product = 1;
+ for (int i = 0; i < nums.length; i++) {
+ product *= nums[i];
+ if (nums[i] == 0) {
+ zero.add(i);
+ }
+ }
+
+ // 0的个数大于1个
+ if (zero.size() > 1) {
+ return result;
+ } else if (zero.size() == 1) {
+ int firstZeroIndex = 0;
+ for (Integer i : zero) {
+ firstZeroIndex = i;
+ }
+
+ result[firstZeroIndex] = 1;
+ for (int i = 0; i < nums.length; i++) {
+ if (i != firstZeroIndex) {
+ result[firstZeroIndex] *= nums[i];
+ }
+ }
+
+ return result;
+ } else {
+ // 没有0
+ for (int i = 0; i < nums.length; i++) {
+ result[i] = (int) (product / nums[i]);
+ }
+
+ return result;
+ }
+
+ }
+}
diff --git a/[0240][Search a 2D Matrix II]/[0240][Search a 2D Matrix II].iml b/[0240][Search a 2D Matrix II]/[0240][Search a 2D Matrix II].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0240][Search a 2D Matrix II]/[0240][Search a 2D Matrix II].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0240][Search a 2D Matrix II]/src/Main.java b/[0240][Search a 2D Matrix II]/src/Main.java
new file mode 100644
index 0000000..33fcd80
--- /dev/null
+++ b/[0240][Search a 2D Matrix II]/src/Main.java
@@ -0,0 +1,23 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-06 20:12
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ int[][] matrix = {
+ {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}
+ };
+ Solution solution = new Solution();
+
+ Assert.assertEquals(true, solution.searchMatrix(matrix, 5));
+ Assert.assertEquals(false, solution.searchMatrix(matrix, 20));
+ }
+}
diff --git a/[0240][Search a 2D Matrix II]/src/Solution.java b/[0240][Search a 2D Matrix II]/src/Solution.java
new file mode 100644
index 0000000..4b780fe
--- /dev/null
+++ b/[0240][Search a 2D Matrix II]/src/Solution.java
@@ -0,0 +1,53 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-06 20:06
+ **/
+public class Solution {
+ /**
+ *
+ * Write an efficient algorithm that searches for a value in an m x n matrix.
+ * This matrix has the following properties:
+ *
+ * Integers in each row are sorted in ascending from left to right.
+ * Integers in each column are sorted in ascending from top to bottom.
+ * Example:
+ *
+ * Consider the following matrix:
+ *
+ * [
+ * [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]
+ * ]
+ * Given target = 5, return true.
+ *
+ * Given target = 20, return false.
+ *
+ *
+ * @param matrix
+ * @param target
+ * @return
+ */
+ public boolean searchMatrix(int[][] matrix, int target) {
+
+ if (matrix == null || matrix.length == 0) {
+ return false;
+ }
+
+ int i = 0;
+ int j = matrix[0].length - 1;
+ while (i < matrix.length && j > -1) {
+ if (matrix[i][j] == target) {
+ return true;
+ } else if (target < matrix[i][j]) {
+ j--;
+ } else {
+ i++;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/[0241][Different Ways to Add Parentheses]/[0241][Different Ways to Add Parentheses].iml b/[0241][Different Ways to Add Parentheses]/[0241][Different Ways to Add Parentheses].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0241][Different Ways to Add Parentheses]/[0241][Different Ways to Add Parentheses].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0241][Different Ways to Add Parentheses]/src/Main.java b/[0241][Different Ways to Add Parentheses]/src/Main.java
new file mode 100644
index 0000000..e2c34b5
--- /dev/null
+++ b/[0241][Different Ways to Add Parentheses]/src/Main.java
@@ -0,0 +1,25 @@
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-06 20:59
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ System.out.println(solution.diffWaysToCompute("2-1-1"));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ System.out.println(solution.diffWaysToCompute("2*3-4*5"));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ System.out.println(solution.diffWaysToCompute("2"));
+ }
+}
diff --git a/[0241][Different Ways to Add Parentheses]/src/Solution.java b/[0241][Different Ways to Add Parentheses]/src/Solution.java
new file mode 100644
index 0000000..d996d4c
--- /dev/null
+++ b/[0241][Different Ways to Add Parentheses]/src/Solution.java
@@ -0,0 +1,113 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-06 20:25
+ **/
+public class Solution {
+ /**
+ *
+ * Given a string of numbers and operators, return all possible results from computing all the
+ * different possible ways to group numbers and operators. The valid operators are +, - and *.
+ *
+ * Example 1:
+ *
+ * Input: "2-1-1"
+ * Output: [0, 2]
+ * Explanation:
+ * ((2-1)-1) = 0
+ * (2-(1-1)) = 2
+ * Example 2:
+ *
+ * Input: "2*3-4*5"
+ * Output: [-34, -14, -10, -10, 10]
+ * Explanation:
+ * (2*(3-(4*5))) = -34
+ * ((2*3)-(4*5)) = -14
+ * ((2*(3-4))*5) = -10
+ * (2*((3-4)*5)) = -10
+ * (((2*3)-4)*5) = 10
+ *
+ *
+ * @param input
+ * @return
+ */
+ public List diffWaysToCompute(String input) {
+ List operator = new ArrayList<>();
+ List operand = new ArrayList<>();
+
+ int start = 0;
+ int end;
+ while (start < input.length()) {
+ end = start + 1;
+ while (end < input.length()
+ && input.charAt(end) >= '0'
+ && input.charAt(end) <= '9') {
+ end++;
+ }
+ operand.add(Integer.parseInt(input.substring(start, end)));
+
+ if (end < input.length()) {
+ operator.add(input.charAt(end));
+ }
+ start = end + 1;
+ }
+
+ return diffWaysToCompute(operand, operator);
+ }
+
+ /**
+ * @param operand
+ * @param operator
+ * @return
+ */
+ private List diffWaysToCompute(List operand, List operator) {
+
+ List result = new LinkedList<>();
+
+ if (operator.isEmpty()) {
+ result.addAll(operand);
+ return result;
+ }
+
+
+ if (operator.size() == 1) {
+ result.add(calculate(operand.get(0), operand.get(1), operator.get(0)));
+ return result;
+ }
+
+ for (int i = 0; i < operator.size(); i++) {
+ List left = diffWaysToCompute(
+ new ArrayList<>(operand.subList(0, i + 1)),
+ new ArrayList<>(operator.subList(0, i)));
+ List right = diffWaysToCompute(
+ new ArrayList<>(operand.subList(i + 1, operand.size())),
+ new ArrayList<>(operator.subList(i + 1, operator.size())));
+
+ for (int x : left) {
+ for (int y : right) {
+ result.add(calculate(x, y, operator.get(i)));
+ }
+ }
+ }
+
+ return result;
+
+ }
+
+ private Integer calculate(Integer a, Integer b, Character op) {
+
+ switch (op) {
+ case '+':
+ return a + b;
+ case '-':
+ return a - b;
+ case '*':
+ return a * b;
+ default:
+ throw new RuntimeException("no such " + a + op + b + " option exception");
+ }
+ }
+}
diff --git a/[0242][Valid Anagram]/[0242][Valid Anagram].iml b/[0242][Valid Anagram]/[0242][Valid Anagram].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0242][Valid Anagram]/[0242][Valid Anagram].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220242\343\200\221\343\200\220Valid Anagram\343\200\221/src/Solution.java" b/[0242][Valid Anagram]/src/Solution.java
similarity index 100%
rename from "\343\200\220242\343\200\221\343\200\220Valid Anagram\343\200\221/src/Solution.java"
rename to [0242][Valid Anagram]/src/Solution.java
diff --git "a/\343\200\220242\343\200\221\343\200\220Valid Anagram\343\200\221/src/Test.java" b/[0242][Valid Anagram]/src/Test.java
similarity index 100%
rename from "\343\200\220242\343\200\221\343\200\220Valid Anagram\343\200\221/src/Test.java"
rename to [0242][Valid Anagram]/src/Test.java
diff --git a/[0257][Binary Tree Paths]/[0257][Binary Tree Paths].iml b/[0257][Binary Tree Paths]/[0257][Binary Tree Paths].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0257][Binary Tree Paths]/[0257][Binary Tree Paths].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/Solution.java" b/[0257][Binary Tree Paths]/src/Solution.java
similarity index 100%
rename from "\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/Solution.java"
rename to [0257][Binary Tree Paths]/src/Solution.java
diff --git "a/\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/Test.java" b/[0257][Binary Tree Paths]/src/Test.java
similarity index 100%
rename from "\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/Test.java"
rename to [0257][Binary Tree Paths]/src/Test.java
diff --git "a/\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/TreeNode.java" b/[0257][Binary Tree Paths]/src/TreeNode.java
similarity index 100%
rename from "\343\200\220257\343\200\221\343\200\220Binary Tree Paths\343\200\221/src/TreeNode.java"
rename to [0257][Binary Tree Paths]/src/TreeNode.java
diff --git a/[0258][Add Digits]/[0258][Add Digits].iml b/[0258][Add Digits]/[0258][Add Digits].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0258][Add Digits]/[0258][Add Digits].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220258\343\200\221\343\200\220Add Digits\343\200\221/src/Solution.java" b/[0258][Add Digits]/src/Solution.java
similarity index 100%
rename from "\343\200\220258\343\200\221\343\200\220Add Digits\343\200\221/src/Solution.java"
rename to [0258][Add Digits]/src/Solution.java
diff --git "a/\343\200\220258\343\200\221\343\200\220Add Digits\343\200\221/src/Test.java" b/[0258][Add Digits]/src/Test.java
similarity index 100%
rename from "\343\200\220258\343\200\221\343\200\220Add Digits\343\200\221/src/Test.java"
rename to [0258][Add Digits]/src/Test.java
diff --git a/[0260][Single Number III]/[0260][Single Number III].iml b/[0260][Single Number III]/[0260][Single Number III].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0260][Single Number III]/[0260][Single Number III].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0260][Single Number III]/src/Main.java b/[0260][Single Number III]/src/Main.java
new file mode 100644
index 0000000..4341777
--- /dev/null
+++ b/[0260][Single Number III]/src/Main.java
@@ -0,0 +1,17 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 18:56
+ **/
+public class Main {
+ @Test
+ public void test1() {
+
+ Solution solution = new Solution();
+ int[] diff = solution.singleNumber(new int[]{1, 2, 1, 3, 2, 5});
+ System.out.println(Arrays.toString(diff));
+ }
+}
diff --git a/[0260][Single Number III]/src/Solution.java b/[0260][Single Number III]/src/Solution.java
new file mode 100644
index 0000000..03c702c
--- /dev/null
+++ b/[0260][Single Number III]/src/Solution.java
@@ -0,0 +1,51 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 18:46
+ **/
+public class Solution {
+ /**
+ *
+ * Given an array of numbers nums, in which exactly two elements appear only
+ * once and all the other elements appear exactly twice. Find the two elements that appear only once.
+ *
+ * Example:
+ *
+ * Input: [1,2,1,3,2,5]
+ * Output: [3,5]
+ * Note:
+ *
+ * The order of the result is not important. So in the above example, [5, 3] is also correct.
+ * Your algorithm should run in linear runtime complexity. Could you implement it using
+ * only constant space complexity?
+ *
+ *
+ * @param nums
+ * @return
+ */
+ public int[] singleNumber(int[] nums) {
+ int xor = nums[0];
+ for (int i = 1; i < nums.length; i++) {
+ xor ^= nums[i];
+ }
+
+ int temp = xor;
+ int count = 0;
+ while ((1 & (temp % 2)) != 1) {
+ count++;
+ temp >>>= 1;
+ }
+
+ int x = 0;
+ int y = 0;
+
+ for (int i : nums) {
+ if (((i >> count) & 1) == 1) {
+ x ^= i;
+ } else {
+ y ^= i;
+ }
+ }
+
+ return new int[]{x, y};
+ }
+}
diff --git a/[0263][Ugly Number]/[0263][Ugly Number].iml b/[0263][Ugly Number]/[0263][Ugly Number].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0263][Ugly Number]/[0263][Ugly Number].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220263\343\200\221\343\200\220Ugly Number\343\200\221/src/Solution.java" b/[0263][Ugly Number]/src/Solution.java
similarity index 100%
rename from "\343\200\220263\343\200\221\343\200\220Ugly Number\343\200\221/src/Solution.java"
rename to [0263][Ugly Number]/src/Solution.java
diff --git "a/\343\200\220263\343\200\221\343\200\220Ugly Number\343\200\221/src/Test.java" b/[0263][Ugly Number]/src/Test.java
similarity index 100%
rename from "\343\200\220263\343\200\221\343\200\220Ugly Number\343\200\221/src/Test.java"
rename to [0263][Ugly Number]/src/Test.java
diff --git a/[0268][Missing Number]/[0268][Missing Number].iml b/[0268][Missing Number]/[0268][Missing Number].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0268][Missing Number]/[0268][Missing Number].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220268\343\200\221\343\200\220Missing Number\343\200\221/src/Solution.java" b/[0268][Missing Number]/src/Solution.java
similarity index 100%
rename from "\343\200\220268\343\200\221\343\200\220Missing Number\343\200\221/src/Solution.java"
rename to [0268][Missing Number]/src/Solution.java
diff --git "a/\343\200\220268\343\200\221\343\200\220Missing Number\343\200\221/src/Test.java" b/[0268][Missing Number]/src/Test.java
similarity index 100%
rename from "\343\200\220268\343\200\221\343\200\220Missing Number\343\200\221/src/Test.java"
rename to [0268][Missing Number]/src/Test.java
diff --git a/[0278][First Bad Version]/[0278][First Bad Version].iml b/[0278][First Bad Version]/[0278][First Bad Version].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0278][First Bad Version]/[0278][First Bad Version].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/Solution.java" b/[0278][First Bad Version]/src/Solution.java
similarity index 100%
rename from "\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/Solution.java"
rename to [0278][First Bad Version]/src/Solution.java
diff --git "a/\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/Test.java" b/[0278][First Bad Version]/src/Test.java
similarity index 100%
rename from "\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/Test.java"
rename to [0278][First Bad Version]/src/Test.java
diff --git "a/\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/VersionControl.java" b/[0278][First Bad Version]/src/VersionControl.java
similarity index 88%
rename from "\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/VersionControl.java"
rename to [0278][First Bad Version]/src/VersionControl.java
index d124b97..327bc14 100644
--- "a/\343\200\220278\343\200\221\343\200\220First Bad Version\343\200\221/src/VersionControl.java"
+++ b/[0278][First Bad Version]/src/VersionControl.java
@@ -6,7 +6,7 @@ public class VersionControl {
private boolean[] badVersion;
- public boolean isBadVersion(int version){
+ public boolean isBadVersion(int version) {
return badVersion[version - 1];
}
diff --git a/[0283][Move Zeroes]/[0283][Move Zeroes].iml b/[0283][Move Zeroes]/[0283][Move Zeroes].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0283][Move Zeroes]/[0283][Move Zeroes].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220283\343\200\221\343\200\220Move Zeroes\343\200\221/src/Solution.java" b/[0283][Move Zeroes]/src/Solution.java
similarity index 100%
rename from "\343\200\220283\343\200\221\343\200\220Move Zeroes\343\200\221/src/Solution.java"
rename to [0283][Move Zeroes]/src/Solution.java
diff --git "a/\343\200\220283\343\200\221\343\200\220Move Zeroes\343\200\221/src/Test.java" b/[0283][Move Zeroes]/src/Test.java
similarity index 100%
rename from "\343\200\220283\343\200\221\343\200\220Move Zeroes\343\200\221/src/Test.java"
rename to [0283][Move Zeroes]/src/Test.java
diff --git a/[0287][Find the Duplicate Number]/[0287][Find the Duplicate Number].iml b/[0287][Find the Duplicate Number]/[0287][Find the Duplicate Number].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0287][Find the Duplicate Number]/[0287][Find the Duplicate Number].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0287][Find the Duplicate Number]/src/Main.java b/[0287][Find the Duplicate Number]/src/Main.java
new file mode 100644
index 0000000..b69e3e5
--- /dev/null
+++ b/[0287][Find the Duplicate Number]/src/Main.java
@@ -0,0 +1,20 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 19:08
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(2, solution.findDuplicate(new int[]{1, 3, 4, 2, 2}));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(3, solution.findDuplicate(new int[]{3, 1, 3, 4, 2}));
+ }
+}
diff --git a/[0287][Find the Duplicate Number]/src/Solution.java b/[0287][Find the Duplicate Number]/src/Solution.java
new file mode 100644
index 0000000..4ab1587
--- /dev/null
+++ b/[0287][Find the Duplicate Number]/src/Solution.java
@@ -0,0 +1,55 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 19:04
+ **/
+public class Solution {
+ /**
+ *
+ * Given an array nums containing n + 1 integers where each integer is between 1
+ * and n (inclusive), prove that at least one duplicate number must exist. Assume
+ * that there is only one duplicate number, find the duplicate one.
+ *
+ * Example 1:
+ *
+ * Input: [1,3,4,2,2]
+ * Output: 2
+ * Example 2:
+ *
+ * Input: [3,1,3,4,2]
+ * Output: 3
+ * Note:
+ *
+ * You must not modify the array (assume the array is read only).
+ * You must use only constant, O(1) extra space.
+ * Your runtime complexity should be less than O(n2).
+ * There is only one duplicate number in the array, but it could be repeated more than once.
+ *
+ *
+ * @param nums
+ * @return
+ */
+ public int findDuplicate(int[] nums) {
+
+ for (int i = 1; i <= nums.length; i++) {
+ // nums[i - 1] != i ; 当 num[8] = 9 的情况
+ // nums[i - 1] != nums[nums[i - 1] - 1] ; 两个相同的数，位置被占用
+ while (nums[i - 1] != i && nums[i - 1] != nums[nums[i - 1] - 1]) {
+ swap(nums, i - 1, nums[i - 1] - 1);
+ }
+ }
+
+ for (int i = 1; i <= nums.length; i++) {
+ if (nums[i - 1] != i) {
+ return nums[i - 1];
+ }
+ }
+
+ return -1;
+ }
+
+ private void swap(int[] nums, int x, int y) {
+ int temp = nums[x];
+ nums[x] = nums[y];
+ nums[y] = temp;
+ }
+}
diff --git a/[0290][Word Pattern]/[0290][Word Pattern].iml b/[0290][Word Pattern]/[0290][Word Pattern].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0290][Word Pattern]/[0290][Word Pattern].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220290\343\200\221\343\200\220Word Pattern\343\200\221/src/Solution.java" b/[0290][Word Pattern]/src/Solution.java
similarity index 100%
rename from "\343\200\220290\343\200\221\343\200\220Word Pattern\343\200\221/src/Solution.java"
rename to [0290][Word Pattern]/src/Solution.java
diff --git "a/\343\200\220290\343\200\221\343\200\220Word Pattern\343\200\221/src/Test.java" b/[0290][Word Pattern]/src/Test.java
similarity index 100%
rename from "\343\200\220290\343\200\221\343\200\220Word Pattern\343\200\221/src/Test.java"
rename to [0290][Word Pattern]/src/Test.java
diff --git a/[0292][Nim Game]/[0292][Nim Game].iml b/[0292][Nim Game]/[0292][Nim Game].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0292][Nim Game]/[0292][Nim Game].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0292][Nim Game]/src/Solution.java b/[0292][Nim Game]/src/Solution.java
new file mode 100644
index 0000000..a6fa330
--- /dev/null
+++ b/[0292][Nim Game]/src/Solution.java
@@ -0,0 +1,41 @@
+/**
+ * https://leetcode.com/problems/nim-game/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-08 18:39
+ **/
+public class Solution {
+ /**
+ *
+ * You are playing the following Nim Game with your friend: There is a heap of stones on the table,
+ * each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will
+ * be the winner. You will take the first turn to remove the stones.
+ *
+ * Both of you are very clever and have optimal strategies for the game. Write a function to determine
+ * whether you can win the game given the number of stones in the heap.
+ *
+ * Example:
+ *
+ * Input: 4
+ * Output: false
+ * Explanation: If there are 4 stones in the heap, then you will never win the game;
+ * No matter 1, 2, or 3 stones you remove, the last stone will always be
+ * removed by your friend.
+ *
+ * 这题往小说可以追溯到小学奥数或者脑筋急转弯的书中，往大说可以深究到博弈论。然而编程在这里并没有卵用，
+ * 策略在于，因为每个人都取不到4个，假设自己后走，要保证每轮自己和对方取得数量的和是4，这样就能确保每
+ * 轮完后都有4的倍数个石头被取走。这样，如果我们先走的话，先把n除4的余数个石头拿走，这样不管怎样，到最
+ * 后都会留4个下来，对方取1个你就取3个，对方取2个你就取2个，就必赢了。
+ *
+ *
+ * @param n
+ * @return
+ */
+ public boolean canWinNim(int n) {
+ return (n & 0b11) > 0;
+ }
+
+ public boolean canWinNim2(int n) {
+ return n % 4 != 0;
+ }
+}
diff --git a/[0299][Bulls and Cows]/[0299][Bulls and Cows].iml b/[0299][Bulls and Cows]/[0299][Bulls and Cows].iml
new file mode 100644
index 0000000..c70cbf1
--- /dev/null
+++ b/[0299][Bulls and Cows]/[0299][Bulls and Cows].iml
@@ -0,0 +1,21 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0299][Bulls and Cows]/src/Solution.java b/[0299][Bulls and Cows]/src/Solution.java
new file mode 100644
index 0000000..cb785ab
--- /dev/null
+++ b/[0299][Bulls and Cows]/src/Solution.java
@@ -0,0 +1,85 @@
+//You are playing the following Bulls and Cows game with your friend: You write
+//down a number and ask your friend to guess what the number is. Each time your fr
+//iend makes a guess, you provide a hint that indicates how many digits in said gu
+//ess match your secret number exactly in both digit and position (called "bulls")
+// and how many digits match the secret number but locate in the wrong position (c
+//alled "cows"). Your friend will use successive guesses and hints to eventually d
+//erive the secret number.
+//
+// Write a function to return a hint according to the secret number and friend's
+// guess, use A to indicate the bulls and B to indicate the cows.
+//
+// Please note that both secret number and friend's guess may contain duplicate
+//digits.
+//
+// Example 1:
+//
+//
+//Input: secret = "1807", guess = "7810"
+//
+//Output: "1A3B"
+//
+//Explanation: 1 bull and 3 cows. The bull is 8, the cows are 0, 1 and 7.
+//
+// Example 2:
+//
+//
+//Input: secret = "1123", guess = "0111"
+//
+//Output: "1A1B"
+//
+//Explanation: The 1st 1 in friend's guess is a bull, the 2nd or 3rd 1 is a cow.
+//
+//
+// Note: You may assume that the secret number and your friend's guess only cont
+//ain digits, and their lengths are always equal. Related Topics Hash Table
+
+
+import java.util.HashMap;
+import java.util.Map;
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+ public String getHint(String secret, String guess) {
+
+ // 假如参数不合法
+ if (secret == null || guess == null || secret.length() != guess.length()) {
+ throw new IllegalArgumentException("secret: " + secret + ", guess: " + guess);
+ }
+
+ Map indexMap = new HashMap<>();
+ Map countMap = new HashMap<>();
+
+ for (int i = 0; i < secret.length(); i++) {
+ char c = secret.charAt(i);
+ indexMap.put(i, c);
+ countMap.put(c, 1 + countMap.getOrDefault(c, 0)); // 记录字符出现的次数
+ }
+
+ int bull = 0;
+ int cows = 0;
+
+ // 先计算bull
+ for (int i = 0; i < guess.length(); i++) {
+ char c = guess.charAt(i);
+ if (indexMap.get(i) == c) {
+ bull++;
+ indexMap.remove(i); // 删除已经匹配过的位置
+ countMap.put(c, countMap.get(c) - 1);
+ }
+ }
+
+ // 再计算cows
+ for (int i = 0; i < guess.length(); i++) {
+ char c = guess.charAt(i);
+ // 位置没有被匹配过，并且值大于0，说明猜测的值是有的，但是位置错误了
+ if (indexMap.containsKey(i) && countMap.getOrDefault(c, 0) > 0) {
+ cows++;
+ countMap.put(c, countMap.get(c) - 1);
+ }
+ }
+
+ return bull + "A" + cows + "B";
+ }
+}
+//leetcode submit region end(Prohibit modification and deletion)
diff --git a/[0299][Bulls and Cows]/src/TestSolution.java b/[0299][Bulls and Cows]/src/TestSolution.java
new file mode 100644
index 0000000..edc42ed
--- /dev/null
+++ b/[0299][Bulls and Cows]/src/TestSolution.java
@@ -0,0 +1,14 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TestSolution {
+ @Test
+ public void test1() {
+ String[][] data = {{"1807", "7810", "1A3B"}, {"1123", "0111", "1A1B"}, {"11", "10", "1A0B"}};
+
+ for (String[] datum : data) {
+ String result = new Solution().getHint(datum[0], datum[1]);
+ Assert.assertEquals(result, datum[2]);
+ }
+ }
+}
diff --git a/[0303][Range Sum Query - Immutable]/[0303][Range Sum Query - Immutable].iml b/[0303][Range Sum Query - Immutable]/[0303][Range Sum Query - Immutable].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0303][Range Sum Query - Immutable]/[0303][Range Sum Query - Immutable].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220303\343\200\221\343\200\220Range Sum Query - Immutable\343\200\221/src/NumArray.java" b/[0303][Range Sum Query - Immutable]/src/NumArray.java
similarity index 88%
rename from "\343\200\220303\343\200\221\343\200\220Range Sum Query - Immutable\343\200\221/src/NumArray.java"
rename to [0303][Range Sum Query - Immutable]/src/NumArray.java
index fb70aae..c64d89d 100644
--- "a/\343\200\220303\343\200\221\343\200\220Range Sum Query - Immutable\343\200\221/src/NumArray.java"
+++ b/[0303][Range Sum Query - Immutable]/src/NumArray.java
@@ -12,11 +12,11 @@ public NumArray(int[] nums) {
public int sumRange(int i, int j) {
if (i > j) {
- throw new IllegalArgumentException("i = " + i + ", j = " + j +", i must not greater than j");
+ throw new IllegalArgumentException("i = " + i + ", j = " + j + ", i must not greater than j");
}
if (j < 0) {
- throw new IllegalArgumentException("i = " + i + ", j = " + j +", i must not less than 0");
+ throw new IllegalArgumentException("i = " + i + ", j = " + j + ", i must not less than 0");
}
i = i < 0 ? 0 : i;
diff --git "a/\343\200\220303\343\200\221\343\200\220Range Sum Query - Immutable\343\200\221/src/Test.java" b/[0303][Range Sum Query - Immutable]/src/Test.java
similarity index 100%
rename from "\343\200\220303\343\200\221\343\200\220Range Sum Query - Immutable\343\200\221/src/Test.java"
rename to [0303][Range Sum Query - Immutable]/src/Test.java
diff --git a/[0326][Power of Three]/[0326][Power of Three].iml b/[0326][Power of Three]/[0326][Power of Three].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0326][Power of Three]/[0326][Power of Three].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0326][Power of Three]/src/Solution.java b/[0326][Power of Three]/src/Solution.java
new file mode 100644
index 0000000..71d743c
--- /dev/null
+++ b/[0326][Power of Three]/src/Solution.java
@@ -0,0 +1,25 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-11-16 15:21
+ **/
+public class Solution {
+
+ public boolean isPowerOfThree(int n) {
+ double rst = (Math.log10(n) / Math.log10(3));
+ return n > 0 && Double.doubleToLongBits((int) rst) == Double.doubleToLongBits(rst);
+ }
+
+ public boolean isPowerOfThree2(int n) {
+ return (n > 0 && 1162261467 % n == 0);
+ }
+
+ public boolean isPowerOfThree1(int n) {
+ while (n > 1 && n % 3 == 0) {
+ n /= 3;
+ }
+
+ return n == 1;
+ }
+
+
+}
diff --git a/[0326][Power of Three]/src/Test.java b/[0326][Power of Three]/src/Test.java
new file mode 100644
index 0000000..9cb8806
--- /dev/null
+++ b/[0326][Power of Three]/src/Test.java
@@ -0,0 +1,13 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-11-16 15:31
+ **/
+public class Test {
+ public static void main(String[] args) {
+ System.out.println(Double.doubleToLongBits((int) 1.00000000001)
+ == Double.doubleToLongBits(1.00000000001));
+
+ System.out.println(Double.doubleToLongBits((int) 1.00000000000)
+ == Double.doubleToLongBits(1.00000000000));
+ }
+}
diff --git a/[0338][Counting Bits ]/[0338][Counting Bits ].iml b/[0338][Counting Bits ]/[0338][Counting Bits ].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0338][Counting Bits ]/[0338][Counting Bits ].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0338][Counting Bits ]/src/Main.java b/[0338][Counting Bits ]/src/Main.java
new file mode 100644
index 0000000..6fe5d61
--- /dev/null
+++ b/[0338][Counting Bits ]/src/Main.java
@@ -0,0 +1,20 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 20:50
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertArrayEquals(new int[]{0, 1, 1}, solution.countBits(2));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertArrayEquals(new int[]{0, 1, 1, 2, 1, 2}, solution.countBits(5));
+ }
+}
diff --git a/[0338][Counting Bits ]/src/Solution.java b/[0338][Counting Bits ]/src/Solution.java
new file mode 100644
index 0000000..901792b
--- /dev/null
+++ b/[0338][Counting Bits ]/src/Solution.java
@@ -0,0 +1,60 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 20:38
+ **/
+public class Solution {
+
+ /**
+ *
+ * Given a non negative integer number num. For every numbers i in the range
+ * 0 ≤ i ≤ num calculate the number of 1's in their binary representation and
+ * return them as an array.
+ *
+ * Example 1:
+ *
+ * Input: 2
+ * Output: [0,1,1]
+ * Example 2:
+ *
+ * Input: 5
+ * Output: [0,1,1,2,1,2]
+ * Follow up:
+ *
+ * It is very easy to come up with a solution with run time O(n*sizeof(integer)).
+ * But can you do it in linear time O(n) /possibly in a single pass?
+ * Space complexity should be O(n).
+ * Can you do it like a boss? Do it without using any builtin function like
+ * __builtin_popcount in c++ or in any other language.
+ *
+ * 思路：
+ * 使用治法，
+ * i为偶数 bit(i) = bit(i/2)
+ * i为奇数 bit(i) = bit(i/2) + 1
+ *
+ *
+ * @param num
+ * @return
+ */
+ public int[] countBits(int num) {
+ if (num < 0) {
+ return new int[0];
+ } else if (num == 0) {
+ return new int[]{0};
+ } else if (num == 1) {
+ return new int[]{0, 1};
+ }
+
+ int[] dp = new int[num + 1];
+ dp[0] = 0;
+ dp[1] = 1;
+ for (int i = 2; i <= num; i++) {
+ dp[i] += dp[i / 2];
+ // 不是偶数，说明其比 i/2多一个一
+ if (i % 2 != 0) {
+ dp[i]++;
+ }
+ }
+
+ return dp;
+ }
+}
diff --git a/[0342][Power of Four]/[0342][Power of Four].iml b/[0342][Power of Four]/[0342][Power of Four].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0342][Power of Four]/[0342][Power of Four].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/\343\200\220342\343\200\221\343\200\220Power of Four\343\200\221/src/Solution.java" b/[0342][Power of Four]/src/Solution.java
similarity index 100%
rename from "\343\200\220342\343\200\221\343\200\220Power of Four\343\200\221/src/Solution.java"
rename to [0342][Power of Four]/src/Solution.java
diff --git a/[0344][Reverse String]/[0344][Reverse String].iml b/[0344][Reverse String]/[0344][Reverse String].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0344][Reverse String]/[0344][Reverse String].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0344][Reverse String]/src/Solution.java b/[0344][Reverse String]/src/Solution.java
new file mode 100644
index 0000000..b7bc9c5
--- /dev/null
+++ b/[0344][Reverse String]/src/Solution.java
@@ -0,0 +1,25 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-11-16 16:04
+ **/
+public class Solution {
+ public String reverseString(String s) {
+ if (s == null || s.length() < 1) {
+ return s;
+ }
+
+ char[] chars = s.toCharArray();
+
+ for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
+ swap(chars, i, j);
+ }
+
+ return new String(chars);
+ }
+
+ private void swap(char[] chars, int i, int j) {
+ char tmp = chars[i];
+ chars[i] = chars[j];
+ chars[j] = tmp;
+ }
+}
diff --git a/[0345][Reverse Vowels of a String]/[0345][Reverse Vowels of a String].iml b/[0345][Reverse Vowels of a String]/[0345][Reverse Vowels of a String].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0345][Reverse Vowels of a String]/[0345][Reverse Vowels of a String].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0345][Reverse Vowels of a String]/src/Main.java b/[0345][Reverse Vowels of a String]/src/Main.java
new file mode 100644
index 0000000..e2549b8
--- /dev/null
+++ b/[0345][Reverse Vowels of a String]/src/Main.java
@@ -0,0 +1,14 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-27 20:03
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals("holle", solution.reverseVowels("hello"));
+ }
+}
diff --git a/[0345][Reverse Vowels of a String]/src/Solution.java b/[0345][Reverse Vowels of a String]/src/Solution.java
new file mode 100644
index 0000000..0704432
--- /dev/null
+++ b/[0345][Reverse Vowels of a String]/src/Solution.java
@@ -0,0 +1,47 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-27 19:58
+ **/
+public class Solution {
+ public String reverseVowels(String s) {
+ if (s == null || s.length() == 0) {
+ return s;
+ }
+
+ char[] chars = s.toCharArray();
+
+ int left = 0;
+ int right = s.length() - 1;
+
+ String t = "aeiouAEIOU";
+
+ Set set = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
+
+ while (left < right) {
+ while (left < right && !set.contains(chars[left])) {
+ left++;
+ }
+ while (left < right && !set.contains(chars[right])) {
+ right--;
+ }
+
+ if (left < right) {
+ swap(chars, left, right);
+ left++;
+ right--;
+ }
+ }
+
+ return new String(chars);
+ }
+
+ private void swap(char[] chars, int left, int right) {
+ char temp = chars[left];
+ chars[left] = chars[right];
+ chars[right] = temp;
+ }
+}
diff --git a/[0347][Top K Frequent Elements]/[0347][Top K Frequent Elements].iml b/[0347][Top K Frequent Elements]/[0347][Top K Frequent Elements].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0347][Top K Frequent Elements]/[0347][Top K Frequent Elements].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0347][Top K Frequent Elements]/src/Main.java b/[0347][Top K Frequent Elements]/src/Main.java
new file mode 100644
index 0000000..a5c4d3e
--- /dev/null
+++ b/[0347][Top K Frequent Elements]/src/Main.java
@@ -0,0 +1,19 @@
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 21:13
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ System.out.println(solution.topKFrequent(new int[]{1, 1, 1, 2, 2, 3}, 2));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ System.out.println(solution.topKFrequent(new int[]{4, 1, -1, 2, -1, 2, 3}, 2));
+ }
+}
diff --git a/[0347][Top K Frequent Elements]/src/Solution.java b/[0347][Top K Frequent Elements]/src/Solution.java
new file mode 100644
index 0000000..31cf516
--- /dev/null
+++ b/[0347][Top K Frequent Elements]/src/Solution.java
@@ -0,0 +1,72 @@
+import java.util.*;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 21:03
+ **/
+public class Solution {
+ /**
+ *
+ * Given a non-empty array of integers, return the k most frequent elements.
+ *
+ * Example 1:
+ *
+ * Input: nums = [1,1,1,2,2,3], k = 2
+ * Output: [1,2]
+ * Example 2:
+ *
+ * Input: nums = [1], k = 1
+ * Output: [1]
+ * Note:
+ *
+ * You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
+ * Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+ *
+ *
+ *
+ * @param nums
+ * @param k
+ * @return
+ */
+ public List topKFrequent(int[] nums, int k) {
+ // 用于记录每个数出现的次数
+ Map map = new HashMap<>();
+ // 按出现次数降序，统计出现X的数字有哪些
+ SortedMap> counter = new TreeMap<>(new Comparator() {
+ @Override
+ public int compare(Integer o1, Integer o2) {
+ return o2 - o1;
+ }
+ });
+
+ // 记录每个数字出现的次数
+ for (int i : nums) {
+ map.merge(i, 1, Integer::sum);
+ }
+
+ // 记录出现X次的数字有哪些
+ for (Map.Entry entry : map.entrySet()) {
+ List list = counter.get(entry.getValue());
+ if (list == null) {
+ list = new LinkedList<>();
+ list.add(entry.getKey());
+ counter.put(entry.getValue(), list);
+ } else {
+ list.add(entry.getKey());
+ }
+ }
+
+ // 取K个结果
+ List result = new LinkedList<>();
+ for (List list : counter.values()) {
+ if (result.size() < k) {
+ int size = Math.min(k - result.size(), list.size());
+ result.addAll(list.subList(0, size));
+ } else {
+ break;
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/[0349][Intersection of Two Arrays]/[0349][Intersection of Two Arrays].iml b/[0349][Intersection of Two Arrays]/[0349][Intersection of Two Arrays].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0349][Intersection of Two Arrays]/[0349][Intersection of Two Arrays].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0349][Intersection of Two Arrays]/src/Solution.java b/[0349][Intersection of Two Arrays]/src/Solution.java
new file mode 100644
index 0000000..bf85d7c
--- /dev/null
+++ b/[0349][Intersection of Two Arrays]/src/Solution.java
@@ -0,0 +1,36 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 14:42
+ **/
+public class Solution {
+ public int[] intersection(int[] nums1, int[] nums2) {
+
+ if (nums1 == null || nums1.length < 1 || nums2 == null || nums2.length < 1) {
+ return new int[0];
+ }
+
+ Set set = new HashSet<>();
+ Set result = new HashSet<>();
+
+ for (int i : nums1) {
+ set.add(i);
+ }
+
+ for (int i : nums2) {
+ if (set.contains(i)) {
+ result.add(i);
+ }
+ }
+
+ int[] r = new int[result.size()];
+ int i = 0;
+ for (int n : result) {
+ r[i++] = n;
+ }
+
+ return r;
+ }
+}
diff --git a/[0350][Intersection of Two Arrays II]/[0350][Intersection of Two Arrays II].iml b/[0350][Intersection of Two Arrays II]/[0350][Intersection of Two Arrays II].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0350][Intersection of Two Arrays II]/[0350][Intersection of Two Arrays II].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0350][Intersection of Two Arrays II]/src/Solution.java b/[0350][Intersection of Two Arrays II]/src/Solution.java
new file mode 100644
index 0000000..d8393f7
--- /dev/null
+++ b/[0350][Intersection of Two Arrays II]/src/Solution.java
@@ -0,0 +1,68 @@
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 14:49
+ **/
+public class Solution {
+ /**
+ *
+ * Given two arrays, write a function to compute their intersection.
+ *
+ * Example 1:
+ *
+ * Input: nums1 = [1,2,2,1], nums2 = [2,2]
+ * Output: [2,2]
+ * Example 2:
+ *
+ * Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+ * Output: [4,9]
+ * Note:
+ *
+ * Each element in the result should appear as many times as it shows in both arrays.
+ * The result can be in any order.
+ * Follow up:
+ *
+ * What if the given array is already sorted? How would you optimize your algorithm?
+ * What if nums1's size is small compared to nums2's size? Which algorithm is better?
+ * What if elements of nums2 are stored on disk, and the memory is limited such that
+ * you cannot load all elements into the memory at once?
+ *
+ *
+ * @param nums1
+ * @param nums2
+ * @return
+ */
+ public int[] intersect(int[] nums1, int[] nums2) {
+
+ if (nums1 == null || nums1.length < 1 || nums2 == null || nums2.length < 1) {
+ return new int[0];
+ }
+
+ Map map = new HashMap<>();
+ List result = new LinkedList<>();
+
+ for (int i : nums1) {
+ map.merge(i, 1, Integer::sum);
+ }
+
+ for (int i : nums2) {
+ Integer v = map.get(i);
+ if (v != null && v > 0) {
+ result.add(i);
+ map.put(i, v - 1);
+ }
+ }
+
+ int[] r = new int[result.size()];
+ int i = 0;
+ for (int n : result) {
+ r[i++] = n;
+ }
+
+ return r;
+ }
+}
diff --git a/[0367][Valid Perfect Square]/[0367][Valid Perfect Square].iml b/[0367][Valid Perfect Square]/[0367][Valid Perfect Square].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0367][Valid Perfect Square]/[0367][Valid Perfect Square].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0367][Valid Perfect Square]/src/Main.java b/[0367][Valid Perfect Square]/src/Main.java
new file mode 100644
index 0000000..78690f1
--- /dev/null
+++ b/[0367][Valid Perfect Square]/src/Main.java
@@ -0,0 +1,32 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:18
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(true, solution.isPerfectSquare(16));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(false, solution.isPerfectSquare(14));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ Assert.assertEquals(false, solution.isPerfectSquare(5));
+ }
+
+ @Test
+ public void test4() {
+ Solution solution = new Solution();
+ Assert.assertEquals(false, solution.isPerfectSquare(2147483647));
+ }
+}
diff --git a/[0367][Valid Perfect Square]/src/Solution.java b/[0367][Valid Perfect Square]/src/Solution.java
new file mode 100644
index 0000000..5b8ebe7
--- /dev/null
+++ b/[0367][Valid Perfect Square]/src/Solution.java
@@ -0,0 +1,34 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:10
+ **/
+public class Solution {
+ public boolean isPerfectSquare(int num) {
+ if (num < 0) {
+ return false;
+ }
+
+ if (num == 0 || num == 1) {
+ return true;
+ }
+
+ int left = 0;
+ int right = num;
+ while (left <= right) {
+ int mid = left + (right - left) / 2;
+
+ int sqrt = num / mid;
+ if (mid == sqrt && num % mid == 0) {
+ return true;
+ } else if (mid > sqrt) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+
+
+ }
+
+ return false;
+ }
+}
diff --git a/[0367][Valid Perfect Square]/src/Solution2.java b/[0367][Valid Perfect Square]/src/Solution2.java
new file mode 100644
index 0000000..412343c
--- /dev/null
+++ b/[0367][Valid Perfect Square]/src/Solution2.java
@@ -0,0 +1,41 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:32
+ **/
+public class Solution2 {
+ public boolean isPerfectSquare(int num) {
+ if (num < 0) {
+ return false;
+ }
+
+ if (num == 0 || num == 1) {
+ return true;
+ }
+
+ int left = 0;
+ int right = num;
+ while (left <= right) {
+ int mid = left + (right - left) / 2;
+
+ if (mid < 1) {
+ return false;
+ }
+
+ int sqrt = num / mid;
+ if (mid == sqrt && num % mid == 0) {
+ return true;
+ } else if (mid < sqrt) {
+
+ if (mid + 1 > num / (mid + 1)) {
+ return false;
+ }
+
+ left = mid + 1;
+ } else {
+ right = mid - 1;
+ }
+ }
+
+ return false;
+ }
+}
diff --git "a/\343\200\220003\343\200\221\343\200\220LongestSubstringWithoutRepeatingCharacters\343\200\221/\343\200\220003\343\200\221\343\200\220LongestSubstringWithoutRepeatingCharacters\343\200\221.iml" b/[0371][Sum of Two Integers]/[0371][Sum of Two Integers].iml
similarity index 100%
rename from "\343\200\220003\343\200\221\343\200\220LongestSubstringWithoutRepeatingCharacters\343\200\221/\343\200\220003\343\200\221\343\200\220LongestSubstringWithoutRepeatingCharacters\343\200\221.iml"
rename to [0371][Sum of Two Integers]/[0371][Sum of Two Integers].iml
diff --git a/[0371][Sum of Two Integers]/src/Solution.java b/[0371][Sum of Two Integers]/src/Solution.java
new file mode 100644
index 0000000..411fe08
--- /dev/null
+++ b/[0371][Sum of Two Integers]/src/Solution.java
@@ -0,0 +1,52 @@
+//Calculate the sum of two integers a and b, but you are not allowed to use the
+//operator + and -.
+//
+//
+// Example 1:
+//
+//
+//Input: a = 1, b = 2
+//Output: 3
+//
+//
+//
+// Example 2:
+//
+//
+//Input: a = -2, b = 3
+//Output: 1
+//
+//
+//
+// Related Topics Bit Manipulation
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+
+/**
+ * Author: 王俊超
+ * Time: 2016-07-03 21-25 10:58
+ * CSDN: http://blog.csdn.net/derrantcm
+ * Github: https://github.com/Wang-Jun-Chao
+ * Declaration: All Rights Reserved !!!
+ */
+public class Solution {
+ public int getSum(int a, int b) {
+
+ // 保存不进位值，异或运算结果
+ int xor;
+ // 保存进位结果，与运算，然后左移一位结果
+ int and;
+ do {
+ xor = a ^ b;
+ and = a & b;
+ and <<= 1;
+ a = xor;
+ b = and;
+
+ } while (and != 0);
+
+ return xor;
+ }
+}
+//leetcode submit region end(Prohibit modification and deletion)
diff --git a/[0371][Sum of Two Integers]/src/SolutionTest.java b/[0371][Sum of Two Integers]/src/SolutionTest.java
new file mode 100644
index 0000000..275433e
--- /dev/null
+++ b/[0371][Sum of Two Integers]/src/SolutionTest.java
@@ -0,0 +1,2 @@
+public class SolutionTest {
+}
diff --git a/[0374][Guess Number Higher or Lower]/[0374][Guess Number Higher or Lower].iml b/[0374][Guess Number Higher or Lower]/[0374][Guess Number Higher or Lower].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0374][Guess Number Higher or Lower]/[0374][Guess Number Higher or Lower].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0374][Guess Number Higher or Lower]/src/GuessGame.java b/[0374][Guess Number Higher or Lower]/src/GuessGame.java
new file mode 100644
index 0000000..8ce64cd
--- /dev/null
+++ b/[0374][Guess Number Higher or Lower]/src/GuessGame.java
@@ -0,0 +1,9 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:47
+ **/
+public class GuessGame {
+ int guess(int num) {
+ return 0;
+ }
+}
diff --git a/[0374][Guess Number Higher or Lower]/src/Solution.java b/[0374][Guess Number Higher or Lower]/src/Solution.java
new file mode 100644
index 0000000..05dec89
--- /dev/null
+++ b/[0374][Guess Number Higher or Lower]/src/Solution.java
@@ -0,0 +1,45 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:46
+ **/
+public class Solution extends GuessGame {
+ /**
+ *
+ * We are playing the Guess Game. The game is as follows:
+ *
+ * I pick a number from 1 to n. You have to guess which number I picked.
+ *
+ * Every time you guess wrong, I'll tell you whether the number is higher or lower.
+ *
+ * You call a pre-defined API guess(int num) which returns 3 possible results (-1, 1, or 0):
+ *
+ * -1 : My number is lower
+ * 1 : My number is higher
+ * 0 : Congrats! You got it!
+ * Example :
+ *
+ * Input: n = 10, pick = 6
+ * Output: 6
+ *
+ *
+ * @param n
+ * @return
+ */
+ public int guessNumber(int n) {
+ int left = 1;
+ int right = n;
+ while (left <= right) {
+ int mid = left + (right - left) / 2;
+ int result = guess(mid);
+ if (result == 0) {
+ return mid;
+ } else if (result < 0) {
+ right = mid - 1;
+ } else {
+ left = mid + 1;
+ }
+ }
+
+ return 0;
+ }
+}
diff --git a/[0383][Ransom Note]/[0383][Ransom Note].iml b/[0383][Ransom Note]/[0383][Ransom Note].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0383][Ransom Note]/[0383][Ransom Note].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0383][Ransom Note]/src/Main.java b/[0383][Ransom Note]/src/Main.java
new file mode 100644
index 0000000..c7e5008
--- /dev/null
+++ b/[0383][Ransom Note]/src/Main.java
@@ -0,0 +1,28 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 16:00
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(false, solution.canConstruct("a", "b"));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(false, solution.canConstruct("aa", "ab"));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ Assert.assertEquals(true, solution.canConstruct("aa", "aab"));
+ }
+
+
+}
diff --git a/[0383][Ransom Note]/src/Solution.java b/[0383][Ransom Note]/src/Solution.java
new file mode 100644
index 0000000..77ec03f
--- /dev/null
+++ b/[0383][Ransom Note]/src/Solution.java
@@ -0,0 +1,47 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-28 15:58
+ **/
+public class Solution {
+ /**
+ *
+ * Given an arbitrary ransom note string and another string containing letters
+ * from all the magazines, write a function that will return true if the ransom
+ * note can be constructed from the magazines ; otherwise, it will return false.
+ *
+ * Each letter in the magazine string can only be used once in your ransom note.
+ *
+ * Note:
+ * You may assume that both strings contain only lowercase letters.
+ *
+ * canConstruct("a", "b") -> false
+ * canConstruct("aa", "ab") -> false
+ * canConstruct("aa", "aab") -> true
+ *
+ *
+ * @param ransomNote
+ * @param magazine
+ * @return
+ */
+ public boolean canConstruct(String ransomNote, String magazine) {
+ // 假设输入都是合法的
+
+ int[] chars = new int[26];
+
+ for (int i = 0; i < magazine.length(); i++) {
+ chars[magazine.charAt(i) - 'a']++;
+ }
+
+ for (int i = 0; i < ransomNote.length(); i++) {
+ chars[ransomNote.charAt(i) - 'a']--;
+ }
+
+ for (int n : chars) {
+ if (n < 0) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/[0384][Shuffle an Array]/[0384][Shuffle an Array].iml b/[0384][Shuffle an Array]/[0384][Shuffle an Array].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0384][Shuffle an Array]/[0384][Shuffle an Array].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0384][Shuffle an Array]/src/Main.java b/[0384][Shuffle an Array]/src/Main.java
new file mode 100644
index 0000000..b5a927d
--- /dev/null
+++ b/[0384][Shuffle an Array]/src/Main.java
@@ -0,0 +1,40 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-02 15:56
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ int[] nums = {1, 2, 3};
+ Solution solution = new Solution(nums);
+
+ int[] shuffle = solution.shuffle();
+ System.out.println(Arrays.toString(shuffle));
+
+ int[] reset = solution.reset();
+ Assert.assertArrayEquals(nums, reset);
+
+ shuffle = solution.shuffle();
+ System.out.println(Arrays.toString(shuffle));
+ }
+
+ @Test
+ public void test2() {
+ int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+ Solution solution = new Solution(nums);
+
+ int[] shuffle = solution.shuffle();
+ System.out.println(Arrays.toString(shuffle));
+
+ int[] reset = solution.reset();
+ Assert.assertArrayEquals(nums, reset);
+
+ shuffle = solution.shuffle();
+ System.out.println(Arrays.toString(shuffle));
+ }
+}
diff --git a/[0384][Shuffle an Array]/src/Solution.java b/[0384][Shuffle an Array]/src/Solution.java
new file mode 100644
index 0000000..2f16e89
--- /dev/null
+++ b/[0384][Shuffle an Array]/src/Solution.java
@@ -0,0 +1,61 @@
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-02 15:51
+ **/
+public class Solution {
+
+ private int[] original;
+
+ /**
+ *
+ * // Init an array with set 1, 2, and 3.
+ * int[] nums = {1,2,3};
+ * Solution solution = new Solution(nums);
+ *
+ * // Shuffle the array [1,2,3] and return its result. Any permutation of [1,2,3]
+ * must equally likely to be returned.
+ * solution.shuffle();
+ *
+ * // Resets the array back to its original configuration [1,2,3].
+ * solution.reset();
+ *
+ * // Returns the random shuffling of array [1,2,3].
+ * solution.shuffle();
+ *
+ *
+ * @param nums
+ */
+ public Solution(int[] nums) {
+ original = nums;
+ }
+
+ /**
+ * Resets the array to its original configuration and return it.
+ */
+ public int[] reset() {
+ return Arrays.copyOf(original, original.length);
+ }
+
+ /**
+ * Returns a random shuffling of the array.
+ */
+ public int[] shuffle() {
+ int[] copy = Arrays.copyOf(original, original.length);
+
+ Random random = new Random();
+ for (int i = 0; i < copy.length - 1; i++) {
+ swap(copy, i, i + random.nextInt(copy.length - i));
+ }
+
+ return copy;
+ }
+
+ private void swap(int[] copy, int i, int j) {
+ int t = copy[i];
+ copy[i] = copy[j];
+ copy[j] = t;
+ }
+}
diff --git a/[0387][First Unique Character in a String]/[0387][First Unique Character in a String].iml b/[0387][First Unique Character in a String]/[0387][First Unique Character in a String].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0387][First Unique Character in a String]/[0387][First Unique Character in a String].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0387][First Unique Character in a String]/src/Main.java b/[0387][First Unique Character in a String]/src/Main.java
new file mode 100644
index 0000000..4c695a9
--- /dev/null
+++ b/[0387][First Unique Character in a String]/src/Main.java
@@ -0,0 +1,20 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 13:50
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(0, solution.firstUniqChar("leetcode"));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(2, solution.firstUniqChar("loveleetcode"));
+ }
+}
diff --git a/[0387][First Unique Character in a String]/src/Solution.java b/[0387][First Unique Character in a String]/src/Solution.java
new file mode 100644
index 0000000..ea4eea0
--- /dev/null
+++ b/[0387][First Unique Character in a String]/src/Solution.java
@@ -0,0 +1,59 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 13:43
+ **/
+public class Solution {
+
+ /**
+ *
+ * Given a string, find the first non-repeating character in it and return it's index.
+ * If it doesn't exist, return -1.
+ *
+ * Examples:
+ *
+ * s = "leetcode"
+ * return 0.
+ *
+ * s = "loveleetcode",
+ * return 2.
+ *
+ *
+ * @param s
+ * @return
+ */
+ public int firstUniqChar(String s) {
+ if (s == null || s.length() < 1) {
+ return -1;
+ }
+
+
+ Map map = new HashMap<>(s.length());
+
+ for (int i = 0; i < s.length(); i++) {
+ // 标记字符已经重复
+ if (map.containsKey(s.charAt(i))) {
+ map.put(s.charAt(i), -1);
+ } else {
+ // 记录位置
+ map.put(s.charAt(i), i);
+ }
+ }
+
+ Integer result = null;
+
+ for (Integer n : map.values()) {
+ if (n >= 0) {
+ if (result == null) {
+ result = n;
+ } else {
+ result = Math.min(n, result);
+ }
+ }
+ }
+
+ return result == null ? -1 : result;
+ }
+}
diff --git a/[0389][Find the Difference]/[0389][Find the Difference].iml b/[0389][Find the Difference]/[0389][Find the Difference].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0389][Find the Difference]/[0389][Find the Difference].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0389][Find the Difference]/src/Main.java b/[0389][Find the Difference]/src/Main.java
new file mode 100644
index 0000000..e936514
--- /dev/null
+++ b/[0389][Find the Difference]/src/Main.java
@@ -0,0 +1,25 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 14:00
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals('e', solution.findTheDifference("abcd", "abcde"));
+
+ }
+
+ @Test
+ public void test2() {
+ String s = "ymbgaraibkfmvocpizdydugvalagaivdbfsfbepeyccqfepzvtpyxtbadkhmwmoswrcxnargtlswqemafandgkmydtimuzvjwxvlfwlhvkrgcsithaqlcvrihrwqkpjdhgfgreqoxzfvhjzojhghfwbvpfzectwwhexthbsndovxejsntmjihchaotbgcysfdaojkjldprwyrnischrgmtvjcorypvopfmegizfkvudubnejzfqffvgdoxohuinkyygbdzmshvyqyhsozwvlhevfepdvafgkqpkmcsikfyxczcovrmwqxxbnhfzcjjcpgzjjfateajnnvlbwhyppdleahgaypxidkpwmfqwqyofwdqgxhjaxvyrzupfwesmxbjszolgwqvfiozofncbohduqgiswuiyddmwlwubetyaummenkdfptjczxemryuotrrymrfdxtrebpbjtpnuhsbnovhectpjhfhahbqrfbyxggobsweefcwxpqsspyssrmdhuelkkvyjxswjwofngpwfxvknkjviiavorwyfzlnktmfwxkvwkrwdcxjfzikdyswsuxegmhtnxjraqrdchaauazfhtklxsksbhwgjphgbasfnlwqwukprgvihntsyymdrfovaszjywuqygpvjtvlsvvqbvzsmgweiayhlubnbsitvfxawhfmfiatxvqrcwjshvovxknnxnyyfexqycrlyksderlqarqhkxyaqwlwoqcribumrqjtelhwdvaiysgjlvksrfvjlcaiwrirtkkxbwgicyhvakxgdjwnwmubkiazdjkfmotglclqndqjxethoutvjchjbkoasnnfbgrnycucfpeovruguzumgmgddqwjgdvaujhyqsqtoexmnfuluaqbxoofvotvfoiexbnprrxptchmlctzgqtkivsilwgwgvpidpvasurraqfkcmxhdapjrlrnkbklwkrvoaziznlpor";
+ String t = "qhxepbshlrhoecdaodgpousbzfcqjxulatciapuftffahhlmxbufgjuxstfjvljybfxnenlacmjqoymvamphpxnolwijwcecgwbcjhgdybfffwoygikvoecdggplfohemfypxfsvdrseyhmvkoovxhdvoavsqqbrsqrkqhbtmgwaurgisloqjixfwfvwtszcxwktkwesaxsmhsvlitegrlzkvfqoiiwxbzskzoewbkxtphapavbyvhzvgrrfriddnsrftfowhdanvhjvurhljmpxvpddxmzfgwwpkjrfgqptrmumoemhfpojnxzwlrxkcafvbhlwrapubhveattfifsmiounhqusvhywnxhwrgamgnesxmzliyzisqrwvkiyderyotxhwspqrrkeczjysfujvovsfcfouykcqyjoobfdgnlswfzjmyucaxuaslzwfnetekymrwbvponiaojdqnbmboldvvitamntwnyaeppjaohwkrisrlrgwcjqqgxeqerjrbapfzurcwxhcwzugcgnirkkrxdthtbmdqgvqxilllrsbwjhwqszrjtzyetwubdrlyakzxcveufvhqugyawvkivwonvmrgnchkzdysngqdibhkyboyftxcvvjoggecjsajbuqkjjxfvynrjsnvtfvgpgveycxidhhfauvjovmnbqgoxsafknluyimkczykwdgvqwlvvgdmufxdypwnajkncoynqticfetcdafvtqszuwfmrdggifokwmkgzuxnhncmnsstffqpqbplypapctctfhqpihavligbrutxmmygiyaklqtakdidvnvrjfteazeqmbgklrgrorudayokxptswwkcircwuhcavhdparjfkjypkyxhbgwxbkvpvrtzjaetahmxevmkhdfyidhrdeejapfbafwmdqjqszwnwzgclitdhlnkaiyldwkwwzvhyorgbysyjbxsspnjdewjxbhpsvj";
+ Solution solution = new Solution();
+ Assert.assertEquals('t', solution.findTheDifference(s, t));
+
+ }
+
+}
diff --git a/[0389][Find the Difference]/src/Solution.java b/[0389][Find the Difference]/src/Solution.java
new file mode 100644
index 0000000..a22ff15
--- /dev/null
+++ b/[0389][Find the Difference]/src/Solution.java
@@ -0,0 +1,54 @@
+import java.util.NoSuchElementException;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 13:53
+ **/
+public class Solution {
+ /**
+ *
+ * Given two strings s and t which consist of only lowercase letters.
+ *
+ * String t is generated by random shuffling string s and then add one
+ * more letter at a random position.
+ *
+ * Find the letter that was added in t.
+ *
+ * Example:
+ *
+ * Input:
+ * s = "abcd"
+ * t = "abcde"
+ *
+ * Output:
+ * e
+ *
+ * Explanation:
+ * 'e' is the letter that was added.
+ *
+ *
+ * @param s
+ * @param t
+ * @return
+ */
+ public char findTheDifference(String s, String t) {
+ // 假设输入都是合法的
+ int[] chars = new int[26];
+
+ for (int i = 0; i < s.length(); i++) {
+ chars[s.charAt(i) - 'a']++;
+ }
+
+ for (int i = 0; i < t.length(); i++) {
+ chars[t.charAt(i) - 'a']--;
+ }
+
+ for (int i = 0; i < chars.length; i++) {
+ if (chars[i] < 0) {
+ return (char) ('a' + i);
+ }
+ }
+
+ throw new NoSuchElementException("could not find the difference");
+ }
+}
diff --git a/[0392][Is Subsequence]/[0392][Is Subsequence].iml b/[0392][Is Subsequence]/[0392][Is Subsequence].iml
new file mode 100644
index 0000000..c70cbf1
--- /dev/null
+++ b/[0392][Is Subsequence]/[0392][Is Subsequence].iml
@@ -0,0 +1,21 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0392][Is Subsequence]/src/Solution.java b/[0392][Is Subsequence]/src/Solution.java
new file mode 100644
index 0000000..fd4ddb2
--- /dev/null
+++ b/[0392][Is Subsequence]/src/Solution.java
@@ -0,0 +1,81 @@
+//Given a string s and a string t, check if s is subsequence of t.
+//
+// A subsequence of a string is a new string which is formed from the original s
+//tring by deleting some (can be none) of the characters without disturbing the re
+//lative positions of the remaining characters. (ie, "ace" is a subsequence of "ab
+//cde" while "aec" is not).
+//
+// Follow up:
+//If there are lots of incoming S, say S1, S2, ... , Sk where k >= 1B, and you w
+//ant to check one by one to see if T has its subsequence. In this scenario, how w
+//ould you change your code?
+//
+// Credits:
+//Special thanks to @pbrother for adding this problem and creating all test case
+//s.
+//
+//
+// Example 1:
+// Input: s = "abc", t = "ahbgdc"
+//Output: true
+// Example 2:
+// Input: s = "axc", t = "ahbgdc"
+//Output: false
+//
+//
+// Constraints:
+//
+//
+// 0 <= s.length <= 100
+// 0 <= t.length <= 10^4
+// Both strings consists only of lowercase characters.
+//
+// Related Topics Binary Search Dynamic Programming Greedy
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+
+/**
+ * Author: 王俊超
+ * Time: 2020-06-24 10:48
+ * CSDN: http://blog.csdn.net/derrantcm
+ * Github: https://github.com/Wang-Jun-Chao
+ * Declaration: All Rights Reserved !!!
+ **/
+public class Solution {
+ public boolean isSubsequence(String s, String t) {
+
+ if (s == null && t == null) {
+ return true;
+ }
+
+ if (s == null || t == null) {
+ return false;
+ }
+
+ if (s.length() == 0) {
+ return true;
+ }
+
+ if (t.length() == 0) {
+ return false;
+ }
+
+ int idxT = 0;
+ int idxS = 0;
+ while (idxS < s.length() && idxT < t.length()) {
+
+ if (s.charAt(idxS) == t.charAt(idxT)) {
+ idxS++;
+ idxT++;
+ } else {
+ idxT++;
+ }
+ }
+
+
+ return idxS == s.length();
+
+ }
+}
+//leetcode submit region end(Prohibit modification and deletion)
diff --git a/[0392][Is Subsequence]/src/SolutionTest.java b/[0392][Is Subsequence]/src/SolutionTest.java
new file mode 100644
index 0000000..7cd621c
--- /dev/null
+++ b/[0392][Is Subsequence]/src/SolutionTest.java
@@ -0,0 +1,29 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Author: 王俊超
+ * Time: 2020-06-25 14:03
+ * CSDN: http://blog.csdn.net/derrantcm
+ * Github: https://github.com/Wang-Jun-Chao
+ * Declaration: All Rights Reserved !!!
+ **/
+public class SolutionTest {
+ @Test
+ public void test1() {
+ Object[][] data = {
+
+ {"", "", true},
+ {"", "ahbgdc", true},
+ {"ahbgdc", "", false},
+ {"abc", "ahbgdc", true},
+ {"axc", "ahbgdc", false},
+ {"leetcode", "lleettccooddee", true},
+ };
+
+ for (Object[] datum : data) {
+ Solution s = new Solution();
+ Assert.assertEquals(s.isSubsequence((String) datum[0], (String) datum[1]), datum[2]);
+ }
+ }
+}
diff --git a/[0400][Nth Digit]/[0400][Nth Digit].iml b/[0400][Nth Digit]/[0400][Nth Digit].iml
new file mode 100644
index 0000000..f080bef
--- /dev/null
+++ b/[0400][Nth Digit]/[0400][Nth Digit].iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0400][Nth Digit]/src/Solution.java b/[0400][Nth Digit]/src/Solution.java
new file mode 100644
index 0000000..24a8b8d
--- /dev/null
+++ b/[0400][Nth Digit]/src/Solution.java
@@ -0,0 +1,80 @@
+/**
+ * https://leetcode.com/problems/nth-digit/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-09 15:56
+ **/
+public class Solution {
+ /**
+ *
+ * Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...
+ *
+ * Note:
+ * n is positive and will fit within the range of a 32-bit signed integer (n < 231).
+ *
+ * Example 1:
+ *
+ * Input:
+ * 3
+ *
+ * Output:
+ * 3
+ * Example 2:
+ *
+ * Input:
+ * 11
+ *
+ * Output:
+ * 0
+ *
+ * Explanation:
+ * The 11th digit of the sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... is a 0,
+ * which is part of the number 10.
+ *
+ * https://blog.csdn.net/yeqiuzs/article/details/52573876
+ *
+ * 思路：
+ * 1~9 9个数 9*1=9个digit
+ * 10~99 90个数 90*2=180个digit
+ * 100~999 900个数 900*3=2700个digit
+ * 10^k ~ k个9连成的数 9*10^k个数 (90*10^k)*k个digit
+ *
+ * 所以给点n，首先确定在几位数之间，如在1000~9999还是在其他之间？然后确定是该区间的哪个数？
+ * 最后确定是该数字的哪个digit？
+ * 注意防止溢出。
+ *
+ *
+ *
+ * @param n
+ * @return
+ */
+ public int findNthDigit(int n) {
+ // 记录用多少位
+ int k = 1;
+ // 记录[10..0(k-1个0), ..., k个9]有多少个数字
+ long length = 0;
+ while (n > length) {
+
+ // 记录[0, ..., k个9]有多少位
+ // [10..0(k-1个0), ..., k个9]有 (int) (9 * k * Math.pow(10, k - 1)) 个数字
+ length += (int) (9 * k * Math.pow(10, k - 1));
+ k++;
+ }
+
+ k--;
+ // n >= 9..9, k个9，k取最大满足条件的值，计算有多少个数字
+ length -= (int) (9 * k * Math.pow(10, k - 1));
+ int num;
+
+ if ((n - length) % k == 0) {
+ num = (int) ((int) Math.pow(10, k - 1) + (n - length) / k - 1);
+ String s = String.valueOf(num);
+ return s.charAt(s.length() - 1) - '0';
+ } else {
+ num = (int) ((int) Math.pow(10, k - 1) + (n - length) / k);
+ String s = String.valueOf(num);
+ return s.charAt((int) ((n - length) % k - 1)) - '0';
+ }
+
+ }
+}
diff --git a/[0400][Nth Digit]/src/Solution2.java b/[0400][Nth Digit]/src/Solution2.java
new file mode 100644
index 0000000..4a5b2c9
--- /dev/null
+++ b/[0400][Nth Digit]/src/Solution2.java
@@ -0,0 +1,53 @@
+/**
+ * https://leetcode.com/problems/nth-digit/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-09 15:56
+ **/
+public class Solution2 {
+ /**
+ *
+ * Find the nth digit of the infinite integer sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...
+ *
+ * Note:
+ * n is positive and will fit within the range of a 32-bit signed integer (n < 231).
+ *
+ * Example 1:
+ *
+ * Input:
+ * 3
+ *
+ * Output:
+ * 3
+ * Example 2:
+ *
+ * Input:
+ * 11
+ *
+ * Output:
+ * 0
+ *
+ * Explanation:
+ * The 11th digit of the sequence 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... is a 0, which is part of the number 10.
+ *
+ * https://www.cnblogs.com/grandyang/p/5891871.html
+ *
+ *
+ * @param n
+ * @return
+ */
+ public int findNthDigit(int n) {
+ long len = 1;
+ int cnt = 9;
+ int start = 1;
+ while (n > len * cnt) {
+ n -= len * cnt;
+ ++len;
+ cnt *= 10;
+ start *= 10;
+ }
+ start += (n - 1) / len;
+ String t = "" + start;
+ return t.charAt((int) ((n - 1) % len)) - '0';
+ }
+}
diff --git a/[0401][Binary Watch]/[0401][Binary Watch].iml b/[0401][Binary Watch]/[0401][Binary Watch].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0401][Binary Watch]/[0401][Binary Watch].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0401][Binary Watch]/src/Main.java b/[0401][Binary Watch]/src/Main.java
new file mode 100644
index 0000000..efea389
--- /dev/null
+++ b/[0401][Binary Watch]/src/Main.java
@@ -0,0 +1,19 @@
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-01 14:32
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ System.out.println(solution.readBinaryWatch(1));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ System.out.println(solution.readBinaryWatch(2));
+ }
+}
diff --git a/[0401][Binary Watch]/src/Solution.java b/[0401][Binary Watch]/src/Solution.java
new file mode 100644
index 0000000..8d7c224
--- /dev/null
+++ b/[0401][Binary Watch]/src/Solution.java
@@ -0,0 +1,63 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-01 14:16
+ **/
+public class Solution {
+ public List readBinaryWatch(int num) {
+ List result = new LinkedList<>();
+
+ if (num < 0 || num >= 9) {
+ return result;
+ }
+
+ if (num == 0) {
+ result.add("0:00");
+ return result;
+ }
+
+ int[] values = {1, 2, 4, 8, 1, 2, 4, 8, 16, 32};
+
+ List current = new ArrayList<>();
+ readBinaryWatch(values, 0, num, num, current, result);
+
+ return result;
+ }
+
+ private void readBinaryWatch(int[] values, int start, int left, int total, List current, List result) {
+
+ if (left == 0) {
+ if (total != current.size()) {
+ return;
+ }
+
+ int hour = 0;
+ int minute = 0;
+ for (int i : current) {
+ if (i < 4) {
+ hour += values[i];
+ if (hour > 11) {
+ return;
+ }
+ } else {
+ minute += values[i];
+ if (minute > 59) {
+ return;
+ }
+ }
+ }
+
+ result.add(hour + ":" + (minute < 10 ? "0" + minute : minute));
+ return;
+ }
+
+ for (int i = start; i < values.length - left + 1; i++) {
+ current.add(i);
+ readBinaryWatch(values, i + 1, left - 1, total, current, result);
+ current.remove(current.size() - 1);
+ }
+ }
+}
diff --git a/[0404][Sum of Left Leaves]/[0404][Sum of Left Leaves].iml b/[0404][Sum of Left Leaves]/[0404][Sum of Left Leaves].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0404][Sum of Left Leaves]/[0404][Sum of Left Leaves].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0404][Sum of Left Leaves]/src/Main.java b/[0404][Sum of Left Leaves]/src/Main.java
new file mode 100644
index 0000000..cf253ab
--- /dev/null
+++ b/[0404][Sum of Left Leaves]/src/Main.java
@@ -0,0 +1,28 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 14:18
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ TreeNode root = new TreeNode(3);
+ root.left = new TreeNode(9);
+ root.right = new TreeNode(20);
+ root.right.left = new TreeNode(15);
+ root.right.right = new TreeNode(7);
+
+ Solution solution = new Solution();
+ Assert.assertEquals(24, solution.sumOfLeftLeaves(root));
+ }
+
+ @Test
+ public void test2() {
+ TreeNode root = new TreeNode(1);
+
+ Solution solution = new Solution();
+ Assert.assertEquals(0, solution.sumOfLeftLeaves(root));
+ }
+}
diff --git a/[0404][Sum of Left Leaves]/src/Solution.java b/[0404][Sum of Left Leaves]/src/Solution.java
new file mode 100644
index 0000000..d5a8ad8
--- /dev/null
+++ b/[0404][Sum of Left Leaves]/src/Solution.java
@@ -0,0 +1,50 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-06-30 14:11
+ **/
+public class Solution {
+ /**
+ *
+ * Find the sum of all left leaves in a given binary tree.
+ *
+ * Example:
+ *
+ * 3
+ * / \
+ * 9 20
+ * / \
+ * 15 7
+ *
+ * There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24.
+ *
+ *
+ * @param root
+ * @return
+ */
+ public int sumOfLeftLeaves(TreeNode root) {
+ int[] result = new int[1];
+ sumOfLeftLeaves(root, false, result);
+ return result[0];
+ }
+
+ /**
+ * 计算所有左叶子的和
+ *
+ * @param root
+ * @param result
+ */
+ private void sumOfLeftLeaves(TreeNode root, boolean isLeftLeaf, int[] result) {
+
+ if (root == null) {
+ return;
+ }
+
+ if (root.left == null && root.right == null && isLeftLeaf) {
+ result[0] += root.val;
+ return;
+ }
+
+ sumOfLeftLeaves(root.left, true, result);
+ sumOfLeftLeaves(root.right, false, result);
+ }
+}
diff --git a/[0404][Sum of Left Leaves]/src/TreeNode.java b/[0404][Sum of Left Leaves]/src/TreeNode.java
new file mode 100644
index 0000000..9aec4dd
--- /dev/null
+++ b/[0404][Sum of Left Leaves]/src/TreeNode.java
@@ -0,0 +1,15 @@
+/**
+ * Author:
+ * Date: 2015-08-19
+ * Time: 06:45
+ * Declaration: All Rights Reserved !!!
+ */
+public class TreeNode {
+ int val;
+ TreeNode left;
+ TreeNode right;
+
+ TreeNode(int x) {
+ val = x;
+ }
+}
diff --git a/[0405][Convert a Number to Hexadecimal]/[0405][Convert a Number to Hexadecimal].iml b/[0405][Convert a Number to Hexadecimal]/[0405][Convert a Number to Hexadecimal].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0405][Convert a Number to Hexadecimal]/[0405][Convert a Number to Hexadecimal].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0405][Convert a Number to Hexadecimal]/src/Main.java b/[0405][Convert a Number to Hexadecimal]/src/Main.java
new file mode 100644
index 0000000..0e56b0e
--- /dev/null
+++ b/[0405][Convert a Number to Hexadecimal]/src/Main.java
@@ -0,0 +1,26 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 03:59
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals("1a", solution.toHex(26));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals("ffffffff", solution.toHex(-1));
+ }
+
+ @Test
+ public void test3() {
+ Solution solution = new Solution();
+ Assert.assertEquals("10", solution.toHex(16));
+ }
+}
diff --git a/[0405][Convert a Number to Hexadecimal]/src/Solution.java b/[0405][Convert a Number to Hexadecimal]/src/Solution.java
new file mode 100644
index 0000000..28c3f8f
--- /dev/null
+++ b/[0405][Convert a Number to Hexadecimal]/src/Solution.java
@@ -0,0 +1,54 @@
+/**
+ * https://leetcode.com/problems/convert-a-number-to-hexadecimal/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 03:55
+ **/
+public class Solution {
+ /**
+ *
+ * Given an integer, write an algorithm to convert it to hexadecimal. For negative integer, two’s complement method is used.
+ *
+ * Note:
+ *
+ * All letters in hexadecimal (a-f) must be in lowercase.
+ * The hexadecimal string must not contain extra leading 0s. If the number is zero, it is represented by a single zero character '0'; otherwise, the first character in the hexadecimal string will not be the zero character.
+ * The given number is guaranteed to fit within the range of a 32-bit signed integer.
+ * You must not use any method provided by the library which converts/formats the number to hex directly.
+ * Example 1:
+ *
+ * Input:
+ * 26
+ *
+ * Output:
+ * "1a"
+ * Example 2:
+ *
+ * Input:
+ * -1
+ *
+ * Output:
+ * "ffffffff"
+ *
+ *
+ * @param num
+ * @return
+ */
+ public String toHex(int num) {
+ String result = "";
+ String hex = "0123456789abcdef";
+ int mask = 0b1111;
+
+ int i;
+ do {
+ // 取低四位的值
+ i = num & mask;
+ // 转成16进制
+ result = hex.charAt(i) + result;
+ // 无符号右移四位，直到0
+ num >>>= 4;
+ } while (num > 0);
+
+ return result;
+ }
+}
diff --git a/[0409][Longest Palindrome]/[0409][Longest Palindrome].iml b/[0409][Longest Palindrome]/[0409][Longest Palindrome].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0409][Longest Palindrome]/[0409][Longest Palindrome].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0409][Longest Palindrome]/src/Main.java b/[0409][Longest Palindrome]/src/Main.java
new file mode 100644
index 0000000..61a21bb
--- /dev/null
+++ b/[0409][Longest Palindrome]/src/Main.java
@@ -0,0 +1,20 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 04:15
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ Solution solution = new Solution();
+ Assert.assertEquals(7, solution.longestPalindrome("abccccdd"));
+ }
+
+ @Test
+ public void test2() {
+ Solution solution = new Solution();
+ Assert.assertEquals(7, solution.longestPalindrome("aAaaaaaa"));
+ }
+}
diff --git a/[0409][Longest Palindrome]/src/Solution.java b/[0409][Longest Palindrome]/src/Solution.java
new file mode 100644
index 0000000..6cfa418
--- /dev/null
+++ b/[0409][Longest Palindrome]/src/Solution.java
@@ -0,0 +1,54 @@
+/**
+ * https://leetcode.com/problems/longest-palindrome/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 04:08
+ **/
+public class Solution {
+ /**
+ *
+ * Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.
+ *
+ * This is case sensitive, for example "Aa" is not considered a palindrome here.
+ *
+ * Note:
+ * Assume the length of given string will not exceed 1,010.
+ *
+ * Example:
+ *
+ * Input:
+ * "abccccdd"
+ *
+ * Output:
+ * 7
+ *
+ * Explanation:
+ * One longest palindrome that can be built is "dccaccd", whose length is 7.
+ * 思路
+ * 1、先记录每个字符出现的次数
+ * 2、取每个字符出现的最大的偶数
+ * 3、如果还有剩下的单个字符，只取其中的一个
+ *
+ */
+ public int longestPalindrome(String s) {
+ if (s == null || s.length() < 1) {
+ return 0;
+ }
+
+ int[] counter = new int[256];
+
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ counter[ch - 'A']++;
+ }
+
+ int result = 0;
+ int left = 0;
+ for (int value : counter) {
+ result += 0xFFFFFFFE & value;
+ left |= 0b1 & value;
+ }
+
+ return result + left;
+ }
+}
diff --git a/[0409][Longest Palindrome]/src/Solution1.java b/[0409][Longest Palindrome]/src/Solution1.java
new file mode 100644
index 0000000..797d326
--- /dev/null
+++ b/[0409][Longest Palindrome]/src/Solution1.java
@@ -0,0 +1,60 @@
+/**
+ * https://leetcode.com/problems/longest-palindrome/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 04:08
+ **/
+public class Solution1 {
+ /**
+ *
+ * Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.
+ *
+ * This is case sensitive, for example "Aa" is not considered a palindrome here.
+ *
+ * Note:
+ * Assume the length of given string will not exceed 1,010.
+ *
+ * Example:
+ *
+ * Input:
+ * "abccccdd"
+ *
+ * Output:
+ * 7
+ *
+ * Explanation:
+ * One longest palindrome that can be built is "dccaccd", whose length is 7.
+ * 思路
+ * 1、先记录每个字符出现的次数
+ * 2、取每个字符出现的最大的偶数
+ * 3、如果还有剩下的单个字符，只取其中的一个
+ *
+ */
+ public int longestPalindrome(String s) {
+ if (s == null || s.length() < 1) {
+ return 0;
+ }
+
+ int[] counter = new int[256];
+
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ counter[ch - 'A']++;
+ }
+
+ int result = 0;
+ int left = 0;
+ for (int value : counter) {
+ if (value > 0) {
+ if (value % 2 == 0) {
+ result += value;
+ } else {
+ result += value - 1;
+ left = 1;
+ }
+ }
+ }
+
+ return result + left;
+ }
+}
diff --git a/[0409][Longest Palindrome]/src/Solution2.java b/[0409][Longest Palindrome]/src/Solution2.java
new file mode 100644
index 0000000..ad898f8
--- /dev/null
+++ b/[0409][Longest Palindrome]/src/Solution2.java
@@ -0,0 +1,67 @@
+/**
+ * https://leetcode.com/problems/longest-palindrome/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-03 04:08
+ **/
+public class Solution2 {
+ /**
+ *
+ * Given a string which consists of lowercase or uppercase letters, find the length of the longest palindromes that can be built with those letters.
+ *
+ * This is case sensitive, for example "Aa" is not considered a palindrome here.
+ *
+ * Note:
+ * Assume the length of given string will not exceed 1,010.
+ *
+ * Example:
+ *
+ * Input:
+ * "abccccdd"
+ *
+ * Output:
+ * 7
+ *
+ * Explanation:
+ * One longest palindrome that can be built is "dccaccd", whose length is 7.
+ * 思路
+ * 1、先记录每个字符出现的次数
+ * 2、取每个字符出现的最大的偶数
+ * 3、如果还有剩下的单个字符，只取其中的一个
+ *
+ */
+ public int longestPalindrome(String s) {
+ if (s == null || s.length() < 1) {
+ return 0;
+ }
+
+ int[] counter = new int[26];
+ // TIP: 这里是大小写不敏感的
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ if (ch >= 'a' && ch <= 'z') {
+ counter[ch - 'a']++;
+ } else {
+ counter[ch - 'A']++;
+ }
+ }
+
+ int result = 0;
+ int left = 0;
+ for (int value : counter) {
+ if (value > 0) {
+ if (value % 2 == 0) {
+ result += value;
+// counter[i] = 0;
+ } else {
+ result += value - 1;
+// counter[i] = 1;
+ // 记录还有剩下的1
+ left = 1;
+ }
+ }
+ }
+
+ return result + left;
+ }
+}
diff --git a/[0412][Fizz Buzz]/[0412][Fizz Buzz].iml b/[0412][Fizz Buzz]/[0412][Fizz Buzz].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0412][Fizz Buzz]/[0412][Fizz Buzz].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0412][Fizz Buzz]/src/Main.java b/[0412][Fizz Buzz]/src/Main.java
new file mode 100644
index 0000000..d3164d9
--- /dev/null
+++ b/[0412][Fizz Buzz]/src/Main.java
@@ -0,0 +1,20 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-09 16:37
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ String[] array = {"1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"};
+
+ Solution solution = new Solution();
+
+ Assert.assertEquals(Arrays.asList(array), solution.fizzBuzz(15));
+
+ }
+}
diff --git a/[0412][Fizz Buzz]/src/Solution.java b/[0412][Fizz Buzz]/src/Solution.java
new file mode 100644
index 0000000..12a2ebe
--- /dev/null
+++ b/[0412][Fizz Buzz]/src/Solution.java
@@ -0,0 +1,63 @@
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * https://leetcode.com/problems/fizz-buzz/
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-09 16:34
+ **/
+public class Solution {
+ /**
+ *
+ * Write a program that outputs the string representation of numbers from 1 to n.
+ *
+ * But for multiples of three it should output “Fizz” instead of the number and for
+ * the multiples of five output “Buzz”. For numbers which are multiples of both three
+ * and five output “FizzBuzz”.
+ *
+ * Example:
+ *
+ * n = 15,
+ *
+ * Return:
+ * [
+ * "1",
+ * "2",
+ * "Fizz",
+ * "4",
+ * "Buzz",
+ * "Fizz",
+ * "7",
+ * "8",
+ * "Fizz",
+ * "Buzz",
+ * "11",
+ * "Fizz",
+ * "13",
+ * "14",
+ * "FizzBuzz"
+ * ]
+ *
+ *
+ * @param n
+ * @return
+ */
+ public List fizzBuzz(int n) {
+ List result = new LinkedList<>();
+
+ for (int i = 1; i <= n; i++) {
+ if (i % 15 == 0) {
+ result.add("FizzBuzz");
+ } else if (i % 5 == 0) {
+ result.add("Buzz");
+ } else if (i % 3 == 0) {
+ result.add("Fizz");
+ } else {
+ result.add("" + i);
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/[0414][Third Maximum Number]/[0414][Third Maximum Number].iml b/[0414][Third Maximum Number]/[0414][Third Maximum Number].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0414][Third Maximum Number]/[0414][Third Maximum Number].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/[0414][Third Maximum Number]/src/Main.java b/[0414][Third Maximum Number]/src/Main.java
new file mode 100644
index 0000000..ee6c47b
--- /dev/null
+++ b/[0414][Third Maximum Number]/src/Main.java
@@ -0,0 +1,36 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-02 08:18
+ **/
+public class Main {
+ @Test
+ public void test1() {
+ int[] arr = {3, 2, 1};
+ Solution solution = new Solution();
+ Assert.assertEquals(1, solution.thirdMax(arr));
+ }
+
+ @Test
+ public void test2() {
+ int[] arr = {2, 1};
+ Solution solution = new Solution();
+ Assert.assertEquals(2, solution.thirdMax(arr));
+ }
+
+ @Test
+ public void test3() {
+ int[] arr = {2, 3, 2, 1};
+ Solution solution = new Solution();
+ Assert.assertEquals(1, solution.thirdMax(arr));
+ }
+
+ @Test
+ public void test4() {
+ int[] arr = {1, 2, 2, 5, 3, 5};
+ Solution solution = new Solution();
+ Assert.assertEquals(2, solution.thirdMax(arr));
+ }
+}
diff --git a/[0414][Third Maximum Number]/src/Solution.java b/[0414][Third Maximum Number]/src/Solution.java
new file mode 100644
index 0000000..e64ea97
--- /dev/null
+++ b/[0414][Third Maximum Number]/src/Solution.java
@@ -0,0 +1,56 @@
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2019-07-02 08:09
+ **/
+public class Solution {
+ /**
+ *
+ * Given a non-empty array of integers, return the third maximum number in this array.
+ * If it does not exist, return the maximum number. The time complexity must be in O(n).
+ *
+ * Example 1:
+ * Input: [3, 2, 1]
+ *
+ * Output: 1
+ *
+ * Explanation: The third maximum is 1.
+ * Example 2:
+ * Input: [1, 2]
+ *
+ * Output: 2
+ *
+ * Explanation: The third maximum does not exist, so the maximum (2) is returned instead.
+ * Example 3:
+ * Input: [2, 2, 3, 1]
+ *
+ * Output: 1
+ *
+ * Explanation: Note that the third maximum here means the third maximum distinct number.
+ * Both numbers with value 2 are both considered as second maximum.
+ *
+ *
+ * @param nums
+ * @return
+ */
+ public int thirdMax(int[] nums) {
+ SortedSet result = new TreeSet<>();
+
+ for (int i : nums) {
+ addResult(i, result);
+ }
+
+ return result.size() == 3 ? result.first() : result.last();
+ }
+
+ private void addResult(int i, SortedSet result) {
+ if (result.size() < 3) {
+ result.add(i);
+ } else if (result.size() == 3 && result.first() < i && !result.contains(i)) {
+ result.remove(result.first());
+ result.add(i);
+ }
+ }
+}
diff --git a/[0415][Add Strings]/[0415][Add Strings].iml b/[0415][Add Strings]/[0415][Add Strings].iml
new file mode 100644
index 0000000..c8cb479
--- /dev/null
+++ b/[0415][Add Strings]/[0415][Add Strings].iml
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+
+
+
+
+
+
+