change js to md

Author: BaffinLee

001-100/32. Longest Valid Parentheses.md

@@ -0,0 +1,74 @@
+# 32. Longest Valid Parentheses
+
+- Difficulty: Hard.
+- Related Topics: String, Dynamic Programming.
+- Similar Questions: Valid Parentheses.
+
+## Problem
+
+Given a string containing just the characters ```'('``` and ```')'```, find the length of the longest valid (well-formed) parentheses substring.
+
+**Example 1:**
+
+```
+Input: "(()"
+Output: 2
+Explanation: The longest valid parentheses substring is "()"
+```
+
+**Example 2:**
+
+```
+Input: ")()())"
+Output: 4
+Explanation: The longest valid parentheses substring is "()()"
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var longestValidParentheses = function(s) {
+  var max = 0;
+  var len = s.length;
+  var dp = Array(len).fill(0);
+  var tmp = 0;
+  var getNum = function (index) {
+    return index >= 0 ? dp[index] : 0;
+  };
+
+  for (var i = 1; i < len; i++) {
+    if (s[i] === ')') {
+      if (s[i - 1] === '(') {
+        dp[i] = getNum(i - 2) + 2;
+      } else {
+        tmp = i - dp[i - 1] - 1;
+        if (tmp >= 0 && s[tmp] === '(') {
+          dp[i] = dp[i - 1] + getNum(tmp - 1) + 2;
+        }
+      }
+      max = Math.max(max, dp[i]);
+    }
+  }
+
+  return max;
+};
+```
+
+**Explain:**
+
+动态规划
+1. 建立等长的 dp 数组，填充 0，每个数值代表 s 相应位置处的连续匹配括号的长度
+2. '(' 不影响结果，不处理，数值为 0
+3. ')' 的上一个是 '(' 的话，配对，数值为上一数值 + 2
+4. ')' 的上一个是 ')' 时，这时候要看上一个数值，上一个数值代表连续匹配的括号数量，记为 n
+                         如果回退 n + 1 个，正好是个 '(' 的话，配对，数值为上一数值 + (回退 n + 2 个的数值) + 2
+                                           否则是不匹配，不处理，数值为 0
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

001-100/33. Search in Rotated Sorted Array.md

@@ -0,0 +1,88 @@
+# 33. Search in Rotated Sorted Array
+
+- Difficulty: Medium.
+- Related Topics: Array, Binary Search.
+- Similar Questions: Search in Rotated Sorted Array II, Find Minimum in Rotated Sorted Array.
+
+## Problem
+
+Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+
+(i.e., ```[0,1,2,4,5,6,7]``` might become ```[4,5,6,7,0,1,2]```).
+
+You are given a target value to search. If found in the array return its index, otherwise return ```-1```.
+
+You may assume no duplicate exists in the array.
+
+Your algorithm's runtime complexity must be in the order of **O**(log **n**).
+
+**Example 1:**
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 0
+Output: 4
+```
+
+**Example 2:**
+
+```
+Input: nums = [4,5,6,7,0,1,2], target = 3
+Output: -1
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+  var len = nums.length
+  var left = 0;
+  var right = len - 1;
+  var mid = 0;
+	
+  while (left <= right) {
+    mid = left + Math.floor((right - left) / 2);
+    if (nums[mid] === target) return mid;
+    if (nums[mid] > nums[right]) {
+      if (nums[left] <= target && target < nums[mid]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    } else {
+      if (nums[mid] < target && target <= nums[right]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+  }
+	
+  return -1;
+};
+```
+
+**Explain:**
+
+题意： 
+
+输入数组是已排序的数组在某个点上翻转了一下，比如 01234 在 2 上翻转，变成 23401，在输入数组里找是否存在某个数
+
+解：二分查找
+
+（规律：输入数组中取任意一段，从中间分开，必定有一边是已排序的）
+
+先通过中间值与末尾值比大小，判断已排序的是左边还是右边，当然也可以通过中间值跟起点值比大小来判断
+
+(目标值等于中间值的话，就结束了，其实也包括二分查找的极限情况，区间里只剩一个值)
+
+然后判断目标值是否在已排序的那边，在的话在这边继续查找，否则去另一半继续查找
+
+**Complexity:**
+
+* Time complexity : O(log(n)).
+* Space complexity : O(1).

001-100/34. Search for a Range.md

@@ -0,0 +1,79 @@
+# 34. Search for a Range
+
+- Difficulty: Medium.
+- Related Topics: Array, Binary Search.
+- Similar Questions: First Bad Version.
+
+## Problem
+
+Given an array of integers ```nums``` sorted in ascending order, find the starting and ending position of a given ```target``` value.
+
+Your algorithm's runtime complexity must be in the order of **O**(log **n**).
+
+If the target is not found in the array, return ```[-1, -1]```.
+
+**Example 1:**
+
+```
+Input: nums = [5,7,7,8,8,10], target = 8
+Output: [3,4]
+```
+
+**Example 2:**
+
+```
+Input: nums = [5,7,7,8,8,10], target = 6
+Output: [-1,-1]
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var searchRange = function(nums, target) {
+  var res = [-1, -1];
+  var left = find(nums, target, true);
+  var right = find(nums, target, false);
+  if (!nums.length) return res;
+  if (left > right) return res;
+  return [left, right];
+};
+
+var find = function (nums, target, findLeft) {
+  var left = 0;
+  var right = nums.length - 1;
+  var mid = 0;
+  
+  while (left <= right) {
+    mid = Math.floor((left + right) / 2);
+    if (nums[mid] > target || (findLeft && nums[mid] === target)) {
+      right = mid - 1;
+    } else {
+      left = mid + 1;
+    }
+  }
+  
+  return findLeft ? left : right;
+};
+```
+
+**Explain:**
+
+二分查找：
+
+分两次，第一次找左边位置，第二次找右边位置
+
+1. 中间值小于目标，继续去右半部分找
+2. 中间值大于目标，继续去左半部分找
+3. 中间值等于目标，找左位置时，继续去左半部分找；
+                  找右位置时，继续去右半部分找。
+4. 最终不能找到的话，左位置是会大于右位置的，否则代表找到
+
+**Complexity:**
+
+* Time complexity : O(log(n)).
+* Space complexity : O(1).

001-100/35. Search Insert Position.md

@@ -0,0 +1,79 @@
+# 35. Search Insert Position
+
+- Difficulty: Easy.
+- Related Topics: Array, Binary Search.
+- Similar Questions: First Bad Version.
+
+## Problem
+
+Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
+
+You may assume no duplicates in the array.
+
+**Example 1:**
+
+```
+Input: [1,3,5,6], 5
+Output: 2
+```
+
+**Example 2:**
+
+```
+Input: [1,3,5,6], 2
+Output: 1
+```
+
+**Example 3:**
+
+```
+Input: [1,3,5,6], 7
+Output: 4
+```
+
+**Example 4:**
+
+```
+Input: [1,3,5,6], 0
+Output: 0
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var searchInsert = function(nums, target) {
+  var len = nums.length;
+  var left = 0;
+  var right = len - 1;
+  var mid = 0;
+
+  if (!len) return 0;
+
+  while (left <= right) {
+    mid = Math.floor((left + right) / 2);
+    if (nums[mid] > target) {
+      right = mid - 1;
+    } else if (nums[mid] < target) {
+      left = mid + 1;
+    } else {
+      return mid;
+    }
+  }
+
+  return (nums[mid] > target) ? mid : (mid + 1);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(log(n)).
+* Space complexity : O(1).