docs: 新增No.155、No.160、No.169题解

Author: Mayandev

leetcode刷题/README.md

@@ -17,6 +17,9 @@
 - [No.125 验证回文串](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No125_is-palindrome.md)
 - [No.136 只出现一次的数字](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No136_single-number.md)
 - [No.141 环形链表](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No141_has_cycle.md)
+- [No.155 最小栈](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No155_min-stack.md)
+- [No.160 相交链表](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No160_get-intersection-node.md)
+- [No.169 多数元素](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No169_majority-element.md)
 - [No.189 旋转数组](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No189_rotate-arr.md)
 - [No.206 反转链表](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No206_reverse-list.md)
 - [No.234 回文链表](https://github.com/Mayandev/javascript_algorithm/blob/master/leetcode%E5%88%B7%E9%A2%98/note/No234_is-palindrome.md)

leetcode刷题/note/No155_min-stack.md

@@ -0,0 +1,81 @@
+# No.155 最小栈
+
+设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。
+
+push(x) -- 将元素 x 推入栈中。
+pop() -- 删除栈顶的元素。
+top() -- 获取栈顶元素。
+getMin() -- 检索栈中的最小元素。
+
+## 示例
+
+示例:
+```
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin();   --> 返回 -3.
+minStack.pop();
+minStack.top();      --> 返回 0.
+minStack.getMin();   --> 返回 -2.
+```
+
+## 解题思路
+
+js直接使用数组实现栈，最小值通过遍历查找，代码如下：
+
+```javascript
+/**
+ * initialize your data structure here.
+ */
+var MinStack = function() {
+    this.stack = [];
+    this.min = 0;
+};
+
+/** 
+ * @param {number} x
+ * @return {void}
+ */
+MinStack.prototype.push = function(x) {
+    if (this.stack[this.stack.length - 1] )
+    this.stack.push(x);
+};
+
+/**
+ * @return {void}
+ */
+MinStack.prototype.pop = function() {
+    this.stack.pop();
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.top = function() {
+    return this.stack[this.stack.length - 1];
+};
+
+/**
+ * @return {number}
+ */
+MinStack.prototype.getMin = function() {
+    let min = this.stack[0];
+    for (let i = 1; i < this.stack.length; i++) {
+      if (this.stack[i] < min) {
+        min = this.stack[i];
+      }
+    }
+    return 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刷题/note/No160_get-intersection-node.md

@@ -0,0 +1,102 @@
+# No.160 相交链表
+
+难度：`easy`
+
+编写一个程序，找到两个单链表相交的起始节点。
+
+## 示例
+
+示例 1
+```
+输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+输出：Reference of the node with value = 8
+输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
+```
+
+示例 2：
+```
+输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
+输出：Reference of the node with value = 2
+输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
+``` 
+
+示例 3：
+```
+输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
+输出：null
+输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
+解释：这两个链表不相交，因此返回 null。
+``` 
+
+
+注意：
+
+```
+如果两个链表没有交点，返回 null.
+在返回结果后，两个链表仍须保持原有的结构。
+可假定整个链表结构中没有循环。
+程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
+```
+
+## 解题思路
+
+使用暴力法，遍历 A 的同时，遍历 B 链表，如果有相同的节点，直接返回。
+
+这里使用另一种解法，首先分别遍历链表 A 和 B，计算出链表长度之差为n。
+
+使较长的链表先遍历n，这时候两个链表到链表尾部的距离是相同的，然后同时遍历，通过判断节点是否相同，如果相同直接返回。
+
+代码如下：
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} headA
+ * @param {ListNode} headB
+ * @return {ListNode}
+ */
+var getIntersectionNode = function(headA, headB) {
+    let lengthA=lengthB=0;
+    let curA = headA;
+    let curB = headB;
+    while (curA) {
+      curA = curA.next;
+      lengthA++;
+    }
+    while (curB) {
+      curB = curB.next;
+      lengthB++;
+    }
+    let interval = lengthA - lengthB;
+    curA = headA;
+    curB = headB;
+    
+    if (interval > 0) {
+      while (interval) {
+        curA = curA.next;
+        interval--;
+      }
+    } else {
+      while (interval < 0) {
+        curB = curB.next;
+        interval++;
+      }
+    }
+
+    while (curA || curB) {
+      if (curA == curB) {
+        return curA; 
+      }
+      curA = curA.next;
+      curB = curB.next;
+    }
+    return null;
+};
+```

leetcode刷题/note/No169_majority-element.md

@@ -0,0 +1,56 @@
+# No.169 多数元素
+
+难度：`easy`
+
+给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
+
+你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+
+## 示例
+
+示例 1:
+```
+输入: [3,2,3]
+输出: 3
+```
+
+
+示例 2:
+```
+输入: [2,2,1,1,1,2,2]
+输出: 2
+```
+
+## 解题思路
+
+首先想到的是使用 Map 的方法，遍历整个数组，对每个数组出现的个数进行计数。
+
+代码如下：
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var majorityElement = function(nums) {
+    let cond = nums.length / 2;
+    // 使用 map，记录每个数的出现的个数
+    let map = new Map();
+
+    nums.map(item => {
+      let count = map.get(item) || 0;
+      count++;
+      map.set(item, count); 
+    });
+
+    for (let [key, value] of map) {
+      if (value > cond) {
+        return key;
+      }
+    }
+};
+```
+
+另外一种解题思路，可以通过排序，排序后数组中间的数一定是所要找的数字。
+
+代码：略