finish 80~84

Author: BaffinLee

001-100/80. Remove Duplicates from Sorted Array II.md

@@ -0,0 +1,86 @@
+# 80. Remove Duplicates from Sorted Array II
+
+- Difficulty: Medium.
+- Related Topics: Array, Two Pointers.
+- Similar Questions: Remove Duplicates from Sorted Array.
+
+## Problem
+
+Given a sorted array **nums**, remove the duplicates **in-place** such that duplicates appeared at most **twice** and return the new length.
+
+Do not allocate extra space for another array, you must do this by **modifying the input array in-place** with O(1) extra memory.
+
+**Example 1:**
+
+```
+Given nums = [1,1,1,2,2,3],
+
+Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
+
+It doesn't matter what you leave beyond the returned length.
+```
+
+**Example 2:**
+
+```
+Given nums = [0,0,1,1,1,1,2,3,3],
+
+Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.
+
+It doesn't matter what values are set beyond the returned length.
+```
+
+**Clarification:**
+
+Confused why the returned value is an integer but your answer is an array?
+
+Note that the input array is passed in by **reference**, which means modification to the input array will be known to the caller as well.
+
+Internally you can think of this:
+
+```
+// nums is passed in by reference. (i.e., without making a copy)
+int len = removeDuplicates(nums);
+
+// any modification to nums in your function would be known by the caller.
+// using the length returned by your function, it prints the first len elements.
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var removeDuplicates = function(nums) {
+  var len = nums.length;
+  var index = 0;
+  var last = NaN;
+  var times = 0;
+  for (var i = 0; i < len; i++) {
+    if (nums[i] === last) {
+      if (times < 2) times++;
+      else continue;
+    } else {
+      times = 1;
+    }
+    last = nums[i];
+    nums[index] = nums[i];
+    index++;
+  }
+  return index;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/81. Search in Rotated Sorted Array II.md

@@ -0,0 +1,81 @@
+# 81. Search in Rotated Sorted Array II
+
+- Difficulty: Medium.
+- Related Topics: Array, Binary Search.
+- Similar Questions: Search in Rotated Sorted Array.
+
+## Problem
+
+Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+
+(i.e., ```[0,0,1,2,2,5,6]``` might become ```[2,5,6,0,0,1,2]```).
+
+You are given a target value to search. If found in the array return ```true```, otherwise return ```false```.
+
+**Example 1:**
+
+```
+Input: nums = [2,5,6,0,0,1,2], target = 0
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: nums = [2,5,6,0,0,1,2], target = 3
+Output: false
+```
+
+**Follow up:**
+
+- This is a follow up problem to Search in Rotated Sorted Array, where ```nums``` may contain duplicates.
+- Would this affect the run-time complexity? How and why?
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {boolean}
+ */
+var search = function(nums, target) {
+  var left = 0;
+  var right = nums.length - 1;
+  var mid = 0;
+  while (left <= right) {
+    mid = Math.floor((left + right) / 2);
+    if (nums[mid] === target) return true;
+    if (nums[mid] > nums[left]) {
+      if (nums[left] <= target && target < nums[mid]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    } else if (nums[mid] < nums[left]) {
+      if (nums[mid] < target && target <= nums[right]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    } else {
+      left++;
+    }
+  }
+  return false;
+};
+```
+
+**Explain:**
+
+see [Search in Rotated Sorted Array](./search-in-rotated-sorted-array.html).
+
+1. 判断哪边是有序的
+2. 判断 `target` 在有序的那边还是无序的那边
+
+注意重复数字的情况下，只能一个个移动，因为没法判断在哪边。这样算法最坏的情况就是 `O(n)` 了。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).

001-100/82. Remove Duplicates from Sorted List II.md

@@ -0,0 +1,69 @@
+# 82. Remove Duplicates from Sorted List II
+
+- Difficulty: Medium.
+- Related Topics: Linked List.
+- Similar Questions: Remove Duplicates from Sorted List.
+
+## Problem
+
+Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only **distinct** numbers from the original list.
+
+**Example 1:**
+
+```
+Input: 1->2->3->3->4->4->5
+Output: 1->2->5
+```
+
+**Example 2:**
+
+```
+Input: 1->1->1->2->3
+Output: 2->3
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var deleteDuplicates = function(head) {
+  var newHead = new ListNode(0);
+  var now = newHead;
+  var tmp = head;
+  var val = 0;
+  
+  while (tmp) {
+    val = tmp.val;
+    if (tmp.next && tmp.next.val === val) {
+      tmp = tmp.next;
+      while (tmp && tmp.val === val) tmp = tmp.next;
+    } else {
+      now.next = tmp;
+      now = tmp;
+      tmp = tmp.next;
+      now.next = null;
+    }
+  }
+  
+  return newHead.next;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/83. Remove Duplicates from Sorted List.md

@@ -0,0 +1,59 @@
+# 83. Remove Duplicates from Sorted List
+
+- Difficulty: Easy.
+- Related Topics: Linked List.
+- Similar Questions: Remove Duplicates from Sorted List II.
+
+## Problem
+
+Given a sorted linked list, delete all duplicates such that each element appear only **once**.
+
+**Example 1:**
+
+```
+Input: 1->1->2
+Output: 1->2
+```
+
+**Example 2:**
+
+```
+Input: 1->1->2->3->3
+Output: 1->2->3
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var deleteDuplicates = function(head) {
+  var now = head;
+  while (now) {
+    if (now.next && now.next.val === now.val) {
+      now.next = now.next.next;
+    } else {
+      now = now.next;
+    }
+  }
+  return head;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/84. Largest Rectangle in Histogram.md

@@ -0,0 +1,60 @@
+# 84. Largest Rectangle in Histogram
+
+- Difficulty: Hard.
+- Related Topics: Array, Stack.
+- Similar Questions: Maximal Rectangle.
+
+## Problem
+
+Given **n** non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.
+
+![](https://leetcode.com/static/images/problemset/histogram.png)
+
+Above is a histogram where width of each bar is 1, given height = ```[2,1,5,6,2,3]```.
+
+![](https://leetcode.com/static/images/problemset/histogram_area.png)
+
+The largest rectangle is shown in the shaded area, which has area = ```10``` unit.
+
+**Example:**
+
+```
+Input: [2,1,5,6,2,3]
+Output: 10
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+var largestRectangleArea = function(heights) {
+  var len = heights.length;
+  var stack = [];
+  var max = 0;
+  var h = 0;
+  var w = 0;
+  
+  for (var i = 0; i <= len; i++) {
+    while (stack.length && (i === len || heights[i] <= heights[stack[stack.length - 1]])) {
+      h = heights[stack.pop()];
+      w = stack.length === 0 ? i : i - stack[stack.length - 1] - 1;
+      max = Math.max(max, h * w);
+    }
+    stack.push(i);
+  }
+  
+  return max;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).