Second Commit

Author: Longbao521

SortArray/mergeSortArray_88.md

@@ -66,3 +66,7 @@ var merge=function(nums1,m,nums2,n){
 }
 ```
 
+
+
+**参考资料**
+  [leetcode题解](https://github.com/azl397985856/leetcode)

SortArray/remove-duplicates-from-sorted-array_26.md

@@ -24,6 +24,7 @@ for (int i = 0; i < len; i++) {
 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 
+
 #### 思路：双指针
 
        1.开始时。两个指针指向第一个数字
@@ -45,3 +46,9 @@ for (int i = 0; i < len; i++) {
         return arr.length=slowP+1;
   }
 ```
+
+
+**[leetCode分类刷题](https://github.com/Longbao521/Leetcode_classify) &emsp; 该地址长期、每周更新LeetCode分类刷题**
+
+**参考资料**
+&emsp;&emsp;[leetcode题解](https://github.com/azl397985856/leetcode)

SortArray/two-sum-ii-input-array-is-sorted_167.md

@@ -93,5 +93,9 @@ var twoSum=function(numbers,target){
     return [];
 }
 ```
+
+----
+**[leetCode分类刷题](https://github.com/Longbao521/Leetcode_classify)   该地址长期、每周更新LeetCode分类刷题**
+
 **参考资料**
   [leetcode题解](https://github.com/azl397985856/leetcode)

Stack/Valid Parentheses_20.md

@@ -90,3 +90,8 @@ Problem3: [1021. 删除最外层的括号](https://leetcode-cn.com/problems/remo
       2.如果有多个匹配字段，如解析HTMl或XML标记，因匹配类型过多，可以采用Map哈希表，存储匹配类型
          如:const mapper = {'{': "}","[": "]","(": ")"};
 
+
+
+
+**参考资料**
+  [leetcode题解](https://github.com/azl397985856/leetcode)

Stack/min-stack_155.md

@@ -88,4 +88,74 @@ MinStack.prototype.getMin = function() {
  * var param_4 = obj.getMin()
  */
 ```
-**参考资料**
+---
+但是上面的运行成绩惨不忍睹，有没有优化方法？显然是有的，显然这道题中复杂度最高的就是getMin(),其余不过是一步操作而已，刚开始我故步自封于如何快速查找最小值，而忽略了它初始状态是一个空栈，后面每一次操作都会更新最小值，而不需要到了求getMIN()财去查找
+所以更新为：
+```javascript
+var MinStack = function() {
+  this.stack = [];
+  this.min = Number.MAX_VALUE;
+};
+
+/**
+ * @param {number} x
+ * @return {void}
+ */
+MinStack.prototype.push = function(x) {
+  // update 'min'
+  const min = this.min;
+  if (x < this.min) {
+    this.min = x;
+  }
+  return this.stack.push(x - min);
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function() {
+  const item = this.stack.pop();
+  const min = this.min;
+
+  if (item < 0) {
+    this.min = min - item;
+    return min;
+  }
+  return item + min;
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function() {
+  const item = this.stack[this.stack.length - 1];
+  const min = this.min;
+
+  if (item < 0) {
+    return min;
+  }
+  return item + min;
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function() {
+  return this.min;
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(x)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+```
+
+----
+**[leetCode分类刷题](https://github.com/Longbao521/Leetcode_classify) &emsp; 该地址长期、每周更新LeetCode分类刷题**
+
+**参考资料**
+&emsp;&emsp;[leetcode题解](https://github.com/azl397985856/leetcode)

notSortArr/majority-element_169.md

@@ -0,0 +1,88 @@
+# 169.多数元素
+<font color=gray size=2>2019-12-08 09:58:02 +0800</font>
+<font color=gray size=2>categories: dotnet</font>
+---
+
+>给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
+你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+示例 1:
+输入: [3,2,3]
+输出: 3
+示例 2:
+输入: [2,2,1,1,1,2,2]
+输出: 2
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/majority-element
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+---
+
+#### 信息
++ 大小为n的无序数组
++ 找出书组长出现次数大于n/2（向下取整）
++ 数组非空，给定的数组必有多数元素
+
+#### 思路
++ 遍历数组，记录下每个元素出现的次数，若大于n/2则返回
++ 投票算法。这个算法我调试了好久，才懂了点皮毛，如有错误，敬请指点
+
+投票算法，顾名思义是用投票的思想解题，我们用[2,3,2,1,3,1,3,2,3,2]来做例子
+
++ majority=2,count=1; 初始状态，第一个元素首先得一票
++ majority=2,count=0; 不同元素，majority所指代的元素（竞争者）票数减一
++ majority=2,count=1; 竞争者本来要换人，但是巧在竞争者又得了一票
++ majority=2,count=0; 又丧失一票
++ majority=3,count=1; 换人了，让我们看一下新选手
++ majority=3,count=0; 首战不利呀，看来注定短命呀
++ majority=3,count=1; 恩？打脸了？不错
++ majority=3,count=0; 不要放弃，加油
++ majority=3,count=1; 提前预祝成功了
++ majority=3,count=0; 你无所谓了，我们已经胜利了，胜利者3
+
+
+
+#### 求解
+```javascript
+var majorityElement = function(nums) {
+    var resultNum = Math.floor(nums.length/2);//Math.floor是向下取整，Math.ceil是向上取整
+    if(!resultNum){
+        return nums[0];
+    }
+    var storeMap=new Map();
+    for(let elem of nums){
+        let getNum = storeMap.get(elem);
+        if( getNum === undefined){//get得到的是undefined
+            storeMap.set(elem,1);
+        }else{
+            if(getNum+1>resultNum){
+                return elem;
+            }
+            storeMap.set(elem,getNum+1);
+        }
+    }
+};
+```
+
+
+```javascript
+var majorityElement = function(nums) {
+    var count =1;
+    var marjority=nums[0];
+    for(let elem of nums){
+        if(!count){
+            marjority=elem;
+        }
+        if(elem == marjority){
+            count++;
+        }else{
+            count--;
+        }
+    }
+    return marjority
+};
+```
+
+---
+
+**参考资料**
+[LeetCode题解](https://github.com/azl397985856/leetcode)

notSortArr/maximum-sum-subarray _53.md

@@ -1,5 +1,5 @@
->>53.最大子序和
-给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
+# 53.最大子序和
+>>给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 示例:
 输入: [-2,1,-3,4,-1,2,1,-5,4],
 输出: 6
@@ -37,13 +37,12 @@
 **5.分治法**
 ######  分治法采用树的思想进行求解
 >>我们把数组nums以中间位置（m)分为左（left)右(right)两部分. 那么有， left = nums[0]...nums[m - 1] 和 right = nums[m + 1]...nums[n-1]
-
 最大子序列和的位置有以下三种情况：
-
 5.1.考虑中间元素nums[m], 跨越左右两部分，这里从中间元素开始，往左求出后缀最大，往右求出前缀最大, 保持连续性。
 5.2.不考虑中间元素，最大子序列和出现在左半部分，递归求解左边部分最大子序列和
 5.3.不考虑中间元素，最大子序列和出现在右半部分，递归求解右边部分最大子序列和
 分别求出三种情况下最大子序列和，三者中最大值即为最大子序列和。
+
 ![分治法示意图](../jpg/maximum-sum-subarray-divideconquer.png)
 
 ```javascript
@@ -92,4 +91,43 @@ function maxSubArray_2(arr){
         ans=Math.max(ans,sum);//每一次都要与当前的最大值进行比较，决定是否要更新
     }
  }
- ```
+ ```
+
+ ```javascript
+ function helper(list, m, n) {
+  if (m === n) return list[m];
+  let sum = 0;
+  let lmax = -Number.MAX_VALUE;
+  let rmax = -Number.MAX_VALUE;
+  const mid = ((n - m) >> 1) + m;
+  const l = helper(list, m, mid);
+  const r = helper(list, mid + 1, n);
+  for (let i = mid; i >= m; i--) {
+    sum += list[i];
+    if (sum > lmax) lmax = sum;
+  }
+
+  sum = 0;
+
+  for (let i = mid + 1; i <= n; i++) {
+    sum += list[i];
+    if (sum > rmax) rmax = sum;
+  }
+
+  return Math.max(l, r, lmax + rmax);
+}
+
+function LSS(list) {
+  return helper(list, 0, list.length - 1);
+}
+ ```
+
+
+
+
+
+
+
+
+**参考资料**
+&emsp;&emsp;[leetcode题解](https://github.com/azl397985856/leetcode)

notSortArr/single-number_136.md

@@ -35,4 +35,9 @@ var singleNumber = function(nums) {
   }
   return reslut;
 };
-```
+```
+
+
+
+**参考资料**
+  [leetcode题解](https://github.com/azl397985856/leetcode)

other/factorial-trailing-zeroes_172.md

@@ -0,0 +1,51 @@
+# 172. 阶乘后的零
+<font color=gray size=2>2019-12-04 20:10:19 +0800</font>
+<font color=gray size=2>categories: dotnet</font>
+---
+
+>>给定一个整数 n，返回 n! 结果尾数中零的数量。
+示例 1:
+输入: 3
+输出: 0
+解释: 3! = 6, 尾数中没有零。
+示例 2:
+输入: 5
+输出: 1
+解释: 5! = 120, 尾数中有 1 个零.
+说明: 你算法的时间复杂度应为 O(log n) 。
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/factorial-trailing-zeroes
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+---
+
+#### 信息
++ 返回n的阶乘结果中零的数量
++ 时间复杂度为O(log n) 
+
+#### 思路
+
++ 要求有多少个0，其实就是阶乘后的结果是n*2<sup>k</sup>*5<sup>k</sup>，求k。由于明显2的个数要多于5，所以其结果就是求阶乘中每一个元素分解质因数后一共有多少个5
+
+#### 求解
+```javascript
+var trailingZeroes = function(n) {
+  // tag: 数论
+
+  // if (n === 0) return n;
+
+  // 递归： f(n) = n / 5 + f(n / 5)
+  // return Math.floor(n / 5)  + trailingZeroes(Math.floor(n / 5));
+  let count = 0;
+  while (n >= 5) {
+    count += Math.floor(n / 5);
+    n = Math.floor(n / 5);
+  }
+  return count;
+};
+```
+
+---
+
+**参考资料**
+[LeetCode题解](https://github.com/azl397985856/leetcode)