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/[0231][Power of Two]/src/Solution.java b/[0231][Power of Two]/src/Solution.java
new file mode 100644
index 0000000..dee3309
--- /dev/null
+++ b/[0231][Power of Two]/src/Solution.java
@@ -0,0 +1,28 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:24
+ **/
+public class Solution {
+ public boolean isPowerOfTwo(int n) {
+ if (n < 1) {
+ return false;
+ }
+
+ int remainder;
+ boolean result = false;
+ while (n > 0) {
+ // 求余数
+ remainder = n % 2;
+ n >>>= 1;
+
+ if (n == 0 && remainder == 1) {
+ result = true;
+ break;
+ } else if (n > 0 && remainder == 1) {
+ break;
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/[0231][Power of Two]/src/Test.java b/[0231][Power of Two]/src/Test.java
new file mode 100644
index 0000000..0b8841a
--- /dev/null
+++ b/[0231][Power of Two]/src/Test.java
@@ -0,0 +1,16 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:28
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ System.out.println(solution.isPowerOfTwo(-1));
+ System.out.println(solution.isPowerOfTwo(0));
+ System.out.println(solution.isPowerOfTwo(1));
+ System.out.println(solution.isPowerOfTwo(2));
+ System.out.println(solution.isPowerOfTwo(16));
+ System.out.println(solution.isPowerOfTwo(218));
+ }
+}
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/[0232][Implement Queue using Stacks]/src/MyQueue.java b/[0232][Implement Queue using Stacks]/src/MyQueue.java
new file mode 100644
index 0000000..25f2f3c
--- /dev/null
+++ b/[0232][Implement Queue using Stacks]/src/MyQueue.java
@@ -0,0 +1,55 @@
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:37
+ **/
+class MyQueue {
+
+ private List list;
+
+ /**
+ * Initialize your data structure here.
+ */
+ public MyQueue() {
+ list = new LinkedList<>();
+ }
+
+ /**
+ * Push element x to the back of queue.
+ */
+ public void push(int x) {
+ list.add(x);
+ }
+
+ /**
+ * Removes the element from in front of queue and returns that element.
+ */
+ public int pop() {
+ return list.remove(0);
+ }
+
+ /**
+ * Get the front element.
+ */
+ public int peek() {
+ return list.get(0);
+ }
+
+ /**
+ * Returns whether the queue is empty.
+ */
+ public boolean empty() {
+ return list.isEmpty();
+ }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
diff --git a/[0232][Implement Queue using Stacks]/src/Test.java b/[0232][Implement Queue using Stacks]/src/Test.java
new file mode 100644
index 0000000..4adabf6
--- /dev/null
+++ b/[0232][Implement Queue using Stacks]/src/Test.java
@@ -0,0 +1,15 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 10:58
+ **/
+public class Test {
+ public static void main(String[] args) {
+ MyQueue queue = new MyQueue();
+ queue.push(1);
+ queue.push(2);
+
+ System.out.println(queue.peek());
+ System.out.println(queue.pop());
+ System.out.println(queue.empty());
+ }
+}
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/[0234][Palindrome Linked List]/src/Solution2.java b/[0234][Palindrome Linked List]/src/Solution2.java
new file mode 100644
index 0000000..f6138f7
--- /dev/null
+++ b/[0234][Palindrome Linked List]/src/Solution2.java
@@ -0,0 +1,38 @@
+/**
+ * O(n) time and O(n) space
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:02
+ **/
+public class Solution2 {
+ public boolean isPalindrome(ListNode head) {
+
+ if (head == null) {
+ return true;
+ }
+
+ // 反向链的头
+ ListNode reverseHead = new ListNode(-1);
+
+ ListNode temp = head;
+ ListNode node;
+ // 头插法构建反向链
+ while (temp != null) {
+ node = new ListNode(temp.val);
+ node.next = reverseHead.next;
+ reverseHead.next = node;
+ temp = temp.next;
+ }
+
+ reverseHead = reverseHead.next;
+ while (head != null) {
+ if (head.val != reverseHead.val) {
+ return false;
+ }
+
+ head = head.next;
+ reverseHead = reverseHead.next;
+ }
+ return true;
+ }
+}
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/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/Solution.java b/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/Solution.java
new file mode 100644
index 0000000..632cf2f
--- /dev/null
+++ b/[0235][Lowest Common Ancestor of a Binary Search Tree]/src/Solution.java
@@ -0,0 +1,56 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Definition for a binary tree node.
+ *
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode(int x) { val = x; }
+ * }
+ *
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:32
+ */
+class Solution {
+ public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+
+ List pPath = new ArrayList<>();
+ List qPath = new ArrayList<>();
+
+ search(pPath, root, p);
+ search(qPath, root, q);
+
+ TreeNode ancestor = pPath.get(0);
+
+ int idx = 1;
+ while (idx < pPath.size() && idx < qPath.size()) {
+ p = pPath.get(idx);
+ q = qPath.get(idx);
+ if (p != null && q != null && p.val == q.val) {
+ ancestor = pPath.get(idx);
+ idx++;
+ } else {
+ break;
+ }
+ }
+
+ return ancestor;
+ }
+
+ public void search(List path, TreeNode root, TreeNode node) {
+ path.add(root);
+
+ if (root != null) {
+ if (root.val > node.val) {
+ search(path, root.left, node);
+ }
+ if (root.val < node.val) {
+ search(path, root.right, node);
+ }
+ }
+ }
+}
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/[0242][Valid Anagram]/src/Solution.java b/[0242][Valid Anagram]/src/Solution.java
new file mode 100644
index 0000000..ace39c8
--- /dev/null
+++ b/[0242][Valid Anagram]/src/Solution.java
@@ -0,0 +1,48 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 10:28
+ **/
+public class Solution {
+ public boolean isAnagram(String s, String t) {
+
+ if (s == null && t == null) {
+ return true;
+ } else if (s == null || t == null) {
+ return false;
+ }
+
+ Map map = new HashMap<>();
+
+ for (int i = 0; i < s.length(); i++) {
+ Character c = s.charAt(i);
+ if (map.containsKey(c)) {
+ map.put(c, map.get(c) + 1);
+ } else {
+ map.put(c, 1);
+ }
+ }
+
+ for (int i = 0; i < t.length(); i++) {
+ Character c = t.charAt(i);
+ Integer count = map.get(c);
+ // t有s中不包含的字符串
+ if (count == null) {
+ return false;
+ } else {
+ map.put(c, count - 1);
+ }
+ }
+
+ // map中的值有非0的说明不合法
+ for (Integer i : map.values()) {
+ if (i != 0) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/[0242][Valid Anagram]/src/Test.java b/[0242][Valid Anagram]/src/Test.java
new file mode 100644
index 0000000..5282683
--- /dev/null
+++ b/[0242][Valid Anagram]/src/Test.java
@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 10:35
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ System.out.println(solution.isAnagram("anagram", "nagaram"));
+ System.out.println(solution.isAnagram("rat", "car"));
+ }
+}
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/[0257][Binary Tree Paths]/src/Solution.java b/[0257][Binary Tree Paths]/src/Solution.java
new file mode 100644
index 0000000..6480a96
--- /dev/null
+++ b/[0257][Binary Tree Paths]/src/Solution.java
@@ -0,0 +1,56 @@
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ *
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode(int x) { val = x; }
+ * }
+ *
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 11:16
+ **/
+public class Solution {
+ public List binaryTreePaths(TreeNode root) {
+ List result = new LinkedList<>();
+ binaryTreePaths(root, new LinkedList<>(), result);
+
+ return result;
+ }
+
+ private void binaryTreePaths(TreeNode root, LinkedList path, List result) {
+
+ if (root == null) {
+ return;
+ }
+
+ path.add(root);
+
+ if (root.left == null && root.right == null) {
+ addResult(path, result);
+ } else {
+ binaryTreePaths(root.left, path, result);
+ binaryTreePaths(root.right, path, result);
+ }
+
+ path.remove(path.size() - 1);
+ }
+
+ private void addResult(LinkedList path, List result) {
+ StringBuilder builder = new StringBuilder();
+ if (path != null) {
+ for (TreeNode node : path) {
+ builder.append("->").append(node.val);
+ }
+ }
+
+ if (builder.length() > 0) {
+ result.add(builder.substring(2));
+ }
+ }
+}
diff --git a/[0257][Binary Tree Paths]/src/Test.java b/[0257][Binary Tree Paths]/src/Test.java
new file mode 100644
index 0000000..318a15c
--- /dev/null
+++ b/[0257][Binary Tree Paths]/src/Test.java
@@ -0,0 +1,16 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 11:25
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ TreeNode root = new TreeNode(1);
+ root.left = new TreeNode(2);
+ root.right = new TreeNode(3);
+ root.left.right = new TreeNode(5);
+
+ System.out.println(solution.binaryTreePaths(root));
+ }
+}
diff --git a/[0257][Binary Tree Paths]/src/TreeNode.java b/[0257][Binary Tree Paths]/src/TreeNode.java
new file mode 100644
index 0000000..2e248fe
--- /dev/null
+++ b/[0257][Binary Tree Paths]/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/[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/[0258][Add Digits]/src/Solution.java b/[0258][Add Digits]/src/Solution.java
new file mode 100644
index 0000000..ff595f5
--- /dev/null
+++ b/[0258][Add Digits]/src/Solution.java
@@ -0,0 +1,27 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 13:28
+ **/
+public class Solution {
+ public int addDigits(int num) {
+
+ if (num < 0) {
+ throw new IllegalArgumentException("input num :" + num + ", must not be negative");
+ }
+
+ int result = 0;
+
+ while (num > 0) {
+ result += num % 10;
+ num /= 10;
+
+ // 需要重新进行位相加
+ if (num == 0 && result > 9) {
+ num = result;
+ result = 0;
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/[0258][Add Digits]/src/Test.java b/[0258][Add Digits]/src/Test.java
new file mode 100644
index 0000000..d3afaa3
--- /dev/null
+++ b/[0258][Add Digits]/src/Test.java
@@ -0,0 +1,13 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 13:35
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ System.out.println(solution.addDigits(38));
+ System.out.println(solution.addDigits(999999999));
+ System.out.println(solution.addDigits(100000000));
+ }
+}
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/[0263][Ugly Number]/src/Solution.java b/[0263][Ugly Number]/src/Solution.java
new file mode 100644
index 0000000..a05b03c
--- /dev/null
+++ b/[0263][Ugly Number]/src/Solution.java
@@ -0,0 +1,28 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 13:45
+ **/
+public class Solution {
+ public boolean isUgly(int num) {
+
+ if (num < 1) {
+ return false;
+ } else if (num == 1) {
+ return true;
+ }
+
+ while ((num % 2) == 0) {
+ num /= 2;
+ }
+
+ while ((num % 3) == 0) {
+ num /= 3;
+ }
+
+ while ((num % 5) == 0) {
+ num /= 5;
+ }
+
+ return num == 1;
+ }
+}
diff --git a/[0263][Ugly Number]/src/Test.java b/[0263][Ugly Number]/src/Test.java
new file mode 100644
index 0000000..dccb247
--- /dev/null
+++ b/[0263][Ugly Number]/src/Test.java
@@ -0,0 +1,16 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 13:50
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ System.out.println(solution.isUgly(-1));
+ System.out.println(solution.isUgly(0));
+ System.out.println(solution.isUgly(1));
+ System.out.println(solution.isUgly(6));
+ System.out.println(solution.isUgly(8));
+ System.out.println(solution.isUgly(14));
+ }
+}
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/[0268][Missing Number]/src/Solution.java b/[0268][Missing Number]/src/Solution.java
new file mode 100644
index 0000000..0ad6903
--- /dev/null
+++ b/[0268][Missing Number]/src/Solution.java
@@ -0,0 +1,39 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 14:02
+ **/
+public class Solution {
+ public int missingNumber(int[] nums) {
+
+ if (nums == null || nums.length < 1) {
+ throw new IllegalArgumentException("array should contain at least one element");
+ }
+
+ for (int i = 0; i < nums.length; i++) {
+ // 只会存在一个大于nums.length的数，将其放在数组最后一个位置
+ if (nums[i] > nums.length) {
+ swap(nums, i, nums.length - 1);
+ }
+
+ // 交换位置，直到nums[i] = i
+ while (nums[i] != i && nums[i] < nums.length) {
+ swap(nums, i, nums[i]);
+ }
+ }
+
+ // 找出丢失的元素
+ for (int i = 0; i < nums.length; i++) {
+ if (nums[i] != i) {
+ return i;
+ }
+ }
+
+ return nums.length;
+ }
+
+ private void swap(int[] nums, int x, int y) {
+ int temp = nums[x];
+ nums[x] = nums[y];
+ nums[y] = temp;
+ }
+}
diff --git a/[0268][Missing Number]/src/Test.java b/[0268][Missing Number]/src/Test.java
new file mode 100644
index 0000000..a4452e8
--- /dev/null
+++ b/[0268][Missing Number]/src/Test.java
@@ -0,0 +1,21 @@
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 14:14
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ missingNumber(solution, new int[]{0});
+ missingNumber(solution, new int[]{3, 0, 1});
+ missingNumber(solution, new int[]{9, 6, 4, 2, 3, 5, 7, 0, 1});
+ missingNumber(solution, new int[]{8, 6, 4, 2, 3, 5, 7, 0, 1});
+ }
+
+ private static void missingNumber(Solution solution, int[] array) {
+ System.out.println(solution.missingNumber(array));
+ System.out.println(Arrays.toString(array));
+ }
+}
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/[0278][First Bad Version]/src/Solution.java b/[0278][First Bad Version]/src/Solution.java
new file mode 100644
index 0000000..2f344d1
--- /dev/null
+++ b/[0278][First Bad Version]/src/Solution.java
@@ -0,0 +1,39 @@
+/**
+ *
+ * The isBadVersion API is defined in the parent class VersionControl.
+ * boolean isBadVersion(int version);
+ *
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 14:26
+ **/
+public class Solution extends VersionControl {
+ public int firstBadVersion(int n) {
+
+ if (!isBadVersion(n)) {
+ return 0;
+ }
+
+ int hi = n;
+ int lo = 1;
+ int mid;
+
+ while (hi >= lo) {
+ mid = lo + (hi - lo) / 2;
+ if (isBadVersion(mid)) {
+ // 当前是1号版本，或者前一个是合法版本，那么当前版本就是第一个非法的版本
+ if (mid == 1 || (mid > 1 && !isBadVersion(mid - 1))) {
+ return mid;
+ } else {
+ // 非法的版本在[lo, mid-1]间
+ hi = mid - 1;
+ }
+ } else {
+ // 非法版本在[mid + 1, hi]间
+ lo = mid + 1;
+ }
+ }
+
+ return 0;
+ }
+}
diff --git a/[0278][First Bad Version]/src/Test.java b/[0278][First Bad Version]/src/Test.java
new file mode 100644
index 0000000..3a57cd6
--- /dev/null
+++ b/[0278][First Bad Version]/src/Test.java
@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 16:55
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ solution.setBadVersion(new boolean[]{false, false, false, true, true});
+ System.out.println(solution.firstBadVersion(5));
+ }
+}
diff --git a/[0278][First Bad Version]/src/VersionControl.java b/[0278][First Bad Version]/src/VersionControl.java
new file mode 100644
index 0000000..327bc14
--- /dev/null
+++ b/[0278][First Bad Version]/src/VersionControl.java
@@ -0,0 +1,20 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 14:27
+ **/
+public class VersionControl {
+
+ private boolean[] badVersion;
+
+ public boolean isBadVersion(int version) {
+ return badVersion[version - 1];
+ }
+
+ public boolean[] getBadVersion() {
+ return badVersion;
+ }
+
+ public void setBadVersion(boolean[] badVersion) {
+ this.badVersion = badVersion;
+ }
+}
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/[0283][Move Zeroes]/src/Solution.java b/[0283][Move Zeroes]/src/Solution.java
new file mode 100644
index 0000000..4afeb4a
--- /dev/null
+++ b/[0283][Move Zeroes]/src/Solution.java
@@ -0,0 +1,44 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 17:04
+ **/
+public class Solution {
+ public void moveZeroes(int[] nums) {
+
+ if (nums == null || nums.length < 1) {
+ return;
+ }
+
+ int idx = 0;
+ // 找第一个0的位置
+ while (idx < nums.length && nums[idx] != 0) {
+ idx++;
+ }
+
+ // 数组的值都非0
+ if (idx >= nums.length) {
+ return;
+ }
+
+ int temp = idx + 1;
+
+ while (temp < nums.length) {
+ // 找temp开始第一个非0的位置
+ while (temp < nums.length && nums[temp] == 0) {
+ temp++;
+ }
+
+ // 找到非0值，移动到idx位置
+ if (temp < nums.length) {
+ nums[idx] = nums[temp];
+ idx++;
+ temp++;
+ }
+ }
+
+ // 从[idx, nums.length-1]的长度都设置为0
+ for (int i = idx; i < nums.length; i++) {
+ nums[i] = 0;
+ }
+ }
+}
diff --git a/[0283][Move Zeroes]/src/Test.java b/[0283][Move Zeroes]/src/Test.java
new file mode 100644
index 0000000..1c5d20c
--- /dev/null
+++ b/[0283][Move Zeroes]/src/Test.java
@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 17:11
+ **/
+public class Test {
+ public static void main(String[] args) {
+ moveZeros(new int[]{0, 1, 0, 3, 12});
+ moveZeros(new int[]{2, 1, 6, 3, 12});
+ moveZeros(new int[]{2});
+ moveZeros(new int[]{0});
+ }
+
+ private static void moveZeros(int[] a1) {
+ Solution solution = new Solution();
+ solution.moveZeroes(a1);
+ System.out.println(Arrays.toString(a1));
+ }
+}
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/[0290][Word Pattern]/src/Solution.java b/[0290][Word Pattern]/src/Solution.java
new file mode 100644
index 0000000..580d1c2
--- /dev/null
+++ b/[0290][Word Pattern]/src/Solution.java
@@ -0,0 +1,48 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 17:24
+ **/
+public class Solution {
+ public boolean wordPattern(String pattern, String str) {
+
+ if (pattern == null && str == null) {
+ return true;
+ } else if (pattern == null || str == null) {
+ return false;
+ }
+
+ String[] parts = str.split("\\s+");
+
+ if (pattern.length() != parts.length) {
+ return false;
+ }
+
+ Map map = new HashMap<>();
+ Map rmap = new HashMap<>();
+
+ Character c;
+ for (int i = 0; i < pattern.length(); i++) {
+ c = pattern.charAt(i);
+ if (!map.containsKey(c)) {
+ map.put(c, parts[i]);
+ } else {
+ if (!parts[i].equals(map.get(c))) {
+ return false;
+ }
+ }
+ // 双射，两边都要验证
+ if (!rmap.containsKey(parts[i])) {
+ rmap.put(parts[i], c);
+ } else {
+ if (!c.equals(rmap.get(parts[i]))) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/[0290][Word Pattern]/src/Test.java b/[0290][Word Pattern]/src/Test.java
new file mode 100644
index 0000000..6c75500
--- /dev/null
+++ b/[0290][Word Pattern]/src/Test.java
@@ -0,0 +1,14 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-10 17:29
+ **/
+public class Test {
+ public static void main(String[] args) {
+ Solution solution = new Solution();
+
+ System.out.println(solution.wordPattern("abba", "dog cat cat dog"));
+ System.out.println(solution.wordPattern("abba", "dog cat cat fish"));
+ System.out.println(solution.wordPattern("aaaa", "dog cat cat dog"));
+ System.out.println(solution.wordPattern("abba", "dog dog dog dog"));
+ }
+}
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/[0303][Range Sum Query - Immutable]/src/NumArray.java b/[0303][Range Sum Query - Immutable]/src/NumArray.java
new file mode 100644
index 0000000..c64d89d
--- /dev/null
+++ b/[0303][Range Sum Query - Immutable]/src/NumArray.java
@@ -0,0 +1,34 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-12 13:53
+ **/
+public class NumArray {
+ private int[] nums;
+
+ public NumArray(int[] nums) {
+ this.nums = nums;
+ }
+
+ public int sumRange(int i, int j) {
+
+ if (i > 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");
+ }
+
+ i = i < 0 ? 0 : i;
+ j = j >= nums.length ? nums.length - 1 : j;
+
+ int sum = 0;
+
+
+ for (int k = i; k <= j; k++) {
+ sum += nums[k];
+ }
+
+ return sum;
+ }
+}
diff --git a/[0303][Range Sum Query - Immutable]/src/Test.java b/[0303][Range Sum Query - Immutable]/src/Test.java
new file mode 100644
index 0000000..470204f
--- /dev/null
+++ b/[0303][Range Sum Query - Immutable]/src/Test.java
@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-12 14:17
+ **/
+public class Test {
+ public static void main(String[] args) {
+ NumArray array = new NumArray(new int[]{-2, 0, 3, -5, 2, -1});
+ System.out.println(array.sumRange(0, 2));
+ System.out.println(array.sumRange(2, 5));
+ System.out.println(array.sumRange(0, 5));
+ }
+}
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/[0342][Power of Four]/src/Solution.java b/[0342][Power of Four]/src/Solution.java
new file mode 100644
index 0000000..1466de8
--- /dev/null
+++ b/[0342][Power of Four]/src/Solution.java
@@ -0,0 +1,29 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-11-16 15:43
+ **/
+public class Solution {
+
+ public boolean isPowerOfFour(int num) {
+ return num > 0 && (num & (num - 1)) == 0 && (num - 1) % 3 == 0;
+ }
+
+
+ public boolean isPowerOfFour3(int num) {
+ int n = 0b1010101_01010101_01010101_01010101;
+// int n = 0x55555555;
+ return num > 0 && (num & (num - 1)) == 0 && (num & n) == num;
+ }
+
+ public boolean isPowerOfFour2(int num) {
+ double rst = (Math.log10(num) / Math.log10(4));
+ return num > 0 && Double.doubleToLongBits((int) rst) == Double.doubleToLongBits(rst);
+ }
+
+ public boolean isPowerOfFour1(int num) {
+ while (num > 1 && (num % 4 == 0)) {
+ num /= 4;
+ }
+ return num == 1;
+ }
+}
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 @@
+
+
+
+