update

Author: shuzijun

.gitignore

@@ -21,3 +21,6 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+
+src/main/java/com/shuzijun/leetcode/editor/cn/doc/solution/*.*
+src/main/java/com/shuzijun/leetcode/editor/cn/doc/submission/*.*

.idea/leetcode-pro/editor.xml

@@ -0,0 +1,79 @@
+package com.shuzijun.leetcode.editor.cn;
+
+/**
+ * 已知一个长度为 <code>n</code> 的数组，预先按照升序排列，经由 <code>1</code> 到 <code>n</code> 次 <strong>旋转</strong> 后，得到输入数组。例如，原数组 <code>nums = [0,1,2,4,5,6,7]</code> 在变化后可能得到：
+ * <ul>
+ * <li>若旋转 <code>4</code> 次，则可以得到 <code>[4,5,6,7,0,1,2]</code></li>
+ * <li>若旋转 <code>7</code> 次，则可以得到 <code>[0,1,2,4,5,6,7]</code></li>
+ * </ul>
+ *
+ * <p>注意，数组 <code>[a[0], a[1], a[2], ..., a[n-1]]</code> <strong>旋转一次</strong> 的结果为数组 <code>[a[n-1], a[0], a[1], a[2], ..., a[n-2]]</code> 。</p>
+ *
+ * <p>给你一个元素值 <strong>互不相同</strong> 的数组 <code>nums</code> ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 <strong>最小元素</strong> 。</p>
+ *
+ * <p> </p>
+ *
+ * <p><strong>示例 1：</strong></p>
+ *
+ * <pre>
+ * <strong>输入：</strong>nums = [3,4,5,1,2]
+ * <strong>输出：</strong>1
+ * <strong>解释：</strong>原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
+ * </pre>
+ *
+ * <p><strong>示例 2：</strong></p>
+ *
+ * <pre>
+ * <strong>输入：</strong>nums = [4,5,6,7,0,1,2]
+ * <strong>输出：</strong>0
+ * <strong>解释：</strong>原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
+ * </pre>
+ *
+ * <p><strong>示例 3：</strong></p>
+ *
+ * <pre>
+ * <strong>输入：</strong>nums = [11,13,15,17]
+ * <strong>输出：</strong>11
+ * <strong>解释：</strong>原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
+ * </pre>
+ *
+ * <p> </p>
+ *
+ * <p><strong>提示：</strong></p>
+ *
+ * <ul>
+ * <li><code>n == nums.length</code></li>
+ * <li><code>1 <= n <= 5000</code></li>
+ * <li><code>-5000 <= nums[i] <= 5000</code></li>
+ * <li><code>nums</code> 中的所有整数 <strong>互不相同</strong></li>
+ * <li><code>nums</code> 原来是一个升序排序的数组，并进行了 <code>1</code> 至 <code>n</code> 次旋转</li>
+ * </ul>
+ * <div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div><br><div><li>👍 512</li><li>👎 0</li></div>
+ */
+
+public class Q153FindMinimumInRotatedSortedArray {
+    public static void main(String[] args) {
+        Q153FindMinimumInRotatedSortedArray.Solution solution = new Q153FindMinimumInRotatedSortedArray().new Solution();
+        int[] nums = {4, 5, 6, 7, 0, 1, 2};
+        System.out.println(solution.findMin(nums));
+    }
+
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int findMin(int[] nums) {
+            int low = 0;
+            int high = nums.length - 1;
+            while (low < high) {
+                int pivot = low + (high - low) / 2;
+                if (nums[pivot] < nums[high]) {
+                    high = pivot;
+                } else {
+                    low = pivot + 1;
+                }
+            }
+            return nums[low];
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/cn/Q153FindMinimumInRotatedSortedArray.java

@@ -0,0 +1,76 @@
+package com.shuzijun.leetcode.editor.cn;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值 </strong><em><code>target</code></em>  的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p>
+
+<p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p>
+
+<p>你可以按任意顺序返回答案。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [2,7,11,15], target = 9
+<strong>输出：</strong>[0,1]
+<strong>解释：</strong>因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [3,2,4], target = 6
+<strong>输出：</strong>[1,2]
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [3,3], target = 6
+<strong>输出：</strong>[0,1]
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>2 <= nums.length <= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code></li>
+	<li><code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code></li>
+	<li><strong>只会存在一个有效答案</strong></li>
+</ul>
+
+<p><strong>进阶：</strong>你可以想出一个时间复杂度小于 <code>O(n<sup>2</sup>)</code> 的算法吗？</p>
+<div><div>Related Topics</div><div><li>数组</li><li>哈希表</li></div></div><br><div><li>👍 11546</li><li>👎 0</li></div>
+*/
+  
+public class Q1TwoSum{
+    public static void main(String[] args) {
+        Solution solution = new Q1TwoSum().new Solution();
+        int[] nums = {2, 7, 11, 15};
+        int target = 9;
+        System.out.println(Arrays.toString(solution.twoSum(nums, target)));
+    }
+    //leetcode submit region begin(Prohibit modification and deletion)
+    class Solution {
+        public int[] twoSum(int[] nums, int target) {
+            Map<Integer, Integer> map = new HashMap<Integer, Integer>();
+            for (int i = 0; i < nums.length; i++) {
+                int complement = target - nums[i];
+                if (map.containsKey(complement)) {
+                    return new int[]{map.get(complement), i};
+                }
+                map.put(nums[i], i);
+            }
+            throw new IllegalArgumentException("No two sum solution");
+        }
+    }
+//leetcode submit region end(Prohibit modification and deletion)
+
+}

src/main/java/com/shuzijun/leetcode/editor/cn/Q1TwoSum.java

@@ -0,0 +1,85 @@
+package com.shuzijun.leetcode.editor.cn;
+/**
+<p>整数数组 <code>nums</code> 按升序排列，数组中的值 <strong>互不相同</strong> 。</p>
+
+<p>在传递给函数之前，<code>nums</code> 在预先未知的某个下标 <code>k</code>（<code>0 <= k < nums.length</code>）上进行了 <strong>旋转</strong>，使数组变为 <code>[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]</code>（下标 <strong>从 0 开始</strong> 计数）。例如， <code>[0,1,2,4,5,6,7]</code> 在下标 <code>3</code> 处经旋转后可能变为 <code>[4,5,6,7,0,1,2]</code> 。</p>
+
+<p>给你 <strong>旋转后</strong> 的数组 <code>nums</code> 和一个整数 <code>target</code> ，如果 <code>nums</code> 中存在这个目标值 <code>target</code> ，则返回它的下标，否则返回 <code>-1</code> 。</p>
+
+<p> </p>
+
+<p><strong>示例 1：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [<code>4,5,6,7,0,1,2]</code>, target = 0
+<strong>输出：</strong>4
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [<code>4,5,6,7,0,1,2]</code>, target = 3
+<strong>输出：</strong>-1</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>nums = [1], target = 0
+<strong>输出：</strong>-1
+</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li><code>1 <= nums.length <= 5000</code></li>
+	<li><code>-10^4 <= nums[i] <= 10^4</code></li>
+	<li><code>nums</code> 中的每个值都 <strong>独一无二</strong></li>
+	<li>题目数据保证 <code>nums</code> 在预先未知的某个下标上进行了旋转</li>
+	<li><code>-10^4 <= target <= 10^4</code></li>
+</ul>
+
+<p> </p>
+
+<p><strong>进阶：</strong>你可以设计一个时间复杂度为 <code>O(log n)</code> 的解决方案吗？</p>
+<div><div>Related Topics</div><div><li>数组</li><li>二分查找</li></div></div><br><div><li>👍 1442</li><li>👎 0</li></div>
+*/
+  
+public class Q33SearchInRotatedSortedArray{
+  public static void main(String[] args) {
+       Solution solution = new Q33SearchInRotatedSortedArray().new Solution();
+  }
+  //leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int search(int[] nums, int target) {
+        if (nums.length <= 0) return -1;
+        if (nums.length == 1 && nums[0] == target) return 0;
+        int s = 0;
+        int e = nums.length - 1;
+        while (s <= e) {
+            int m = (s+e)/2;
+            if (nums[m] == target) {
+                return m;
+            }
+            if (nums[m] < nums[e]) {
+                if (nums[m] < target && nums[e] >= target) {
+                    s = m + 1;
+                } else {
+                    e = m - 1;
+                }
+            } else  {
+                if (nums[s] <= target && nums[m] > target) {
+                    e = m - 1;
+                } else {
+                    s = m + 1;
+
+                }
+            }
+        }
+        return -1;
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+}