docs(algorithm): 新增一些文档

- 算法思路整理
- 优化代码
- 更新eslint

Author: Chu Fan

code/algorithm/QuickSort.js code/algorithm/quickSort.jscode/algorithm/QuickSort.js renamed to code/algorithm/quickSort.js

@@ -0,0 +1,84 @@
+/**
+ * 先排序，利用出现一次特性
+ * @param array
+ * @returns {*[]}
+ */
+function findNumsAppearOnceOne(array) {
+  // 数组中元素要么出现一次，要么出现两次，可以先对元素进行排序有点偷懒的样子
+  array = array.sort((a, b) => a - b)
+  const len = array.length
+  // 此时的 数组已经进过排序
+  const onceResult = []
+
+  // 在开头
+  if (array[0] !== array[1]) {
+    onceResult.push(array[0])
+  }
+  // 在中间
+  for (let index = 1; index < len - 1; index++) {
+    if (array[index - 1] !== array[index] && array[index] !== array[index + 1]) {
+      onceResult.push(array[index])
+    }
+  }
+  // 在结尾
+  if (array[array.length - 1] !== array[array.length - 2]) {
+    onceResult.push(array[array.length - 1])
+  }
+  return onceResult
+}
+
+/**
+ * 利用Map统计出现次数
+ * @param array
+ * @returns {*[]}
+ */
+function findNumsAppearOnceTwo(array) {
+  const resMap = new Map()
+
+  // 统计
+  for (const value of array) {
+    if (resMap.has(value)) {
+      resMap.set(value, resMap.get(value) + 1)
+    } else {
+      resMap.set(value, 1)
+    }
+  }
+
+  const onceResult = []
+  // 找出出现一次的
+  for (const [key, value] of resMap) {
+    if (value === 1) {
+      onceResult.push(key)
+    }
+  }
+  // 按从小到大输出
+  return onceResult.sort((a, b) => a - b)
+}
+
+/**
+ * 利用异或运算
+ * @param array
+ * @returns {*[]}
+ */
+function findNumsAppearOnceThree(array) {
+  let res1 = 0
+  let res2 = 0
+  let temp = 0
+  // 遍历数组得到a^b
+  for (let i = 0; i < array.length; i++) { temp ^= array[i] }
+  let k = 1
+
+  // 找到两个数不相同的第一位
+  while ((k & temp) === 0) { k <<= 1 }
+  for (let i = 0; i < array.length; i++) {
+    // 遍历数组，对每个数分类
+    if ((k & array[i]) === 0) { res1 ^= array[i] } else { res2 ^= array[i] }
+  }
+
+  // 升序
+  return res1 > res2 ? [res2, res1] : [res1, res2]
+}
+
+console.log(findNumsAppearOnceOne([1, 2, 3, 3, 2, 9]))
+console.log(findNumsAppearOnceTwo([1, 2, 3, 3, 2, 9]))
+console.log(findNumsAppearOnceThree([1, 2, 3, 3, 2, 9]))

code/algorithm/剑指/位运算/FindNumsAppearOnce.js

@@ -0,0 +1,36 @@
+/**
+ * 斐波那契数列，递归调用
+ * 难度：入门
+ * @param n
+ * @returns {*}
+ * @constructor
+ */
+function fibonacciOne(n) {
+  return n < 2 ? n : fibonacciOne(n - 1) + fibonacciOne(n - 2)
+}
+
+/**
+ * 斐波那契数列，迭代
+ * 难度：入门
+ * @param n
+ */
+function fibonacciTwo(n) {
+  // 数列初始化
+  let firstValue = 0
+  let secondValue = 1
+
+  let result = 1
+  for (let index = 3; index <= n; index++) {
+    // 求和
+    result = firstValue + secondValue
+
+    // 前面两列重新赋值
+    firstValue = secondValue
+    secondValue = result
+  }
+  return result
+}
+
+
+console.log(fibonacciOne(4))
+console.log(fibonacciTwo(4))

code/algorithm/剑指/位运算/findNumsAppearOnce.js

@@ -1,33 +1,40 @@
 
 /**
- * 【中等】跳台阶  递归，要么跳一阶，要么跳两阶
+ * 【简单】跳台阶  递归，要么跳一阶，要么跳两阶
  * 思路： 对于第number台阶，只能从第number-1或者number-2上跳上来
  * 记作： G(number)=G(number-1)+G(number-2)
  * 即： 从第number-1跳上来的次数+从第number-2上跳上来的次数
  *
  */
 
-// 递归实现
-function jumpFloor(number) {
+/**
+ * 递归实现
+  * @param number
+ * @returns {*}
+ */
+function jumpFloorOne(number) {
   // 递归，要么跳一阶，要么跳两阶
-  return number < 3 ? number : jumpFloor(number - 1) + jumpFloor(number - 2)
+  return number < 3 ? number : jumpFloorOne(number - 1) + jumpFloorOne(number - 2)
 }
 
-// 非递归调用
-function jumpFloor01(number) {
+/**
+ * 非递归调用
+ * @param number
+ * @returns {number|*}
+ */
+function jumpFloorTwo(number) {
   let a = 1
   let b = 2
-  let result = 0
-
-  if (number < 3) {
-    return number
-  }
+  let result = 1
 
   for (let index = 3; index <= number; index++) {
     result = a + b
     a = b
     b = result
   }
-
   return result
 }
+
+console.log(jumpFloorOne(7))
+console.log(jumpFloorTwo(7))
+

code/algorithm/剑指/动态规划/Fibonacci.js

@@ -1,17 +1,23 @@
-function jumpFloorII(number) {
-  // 我tm跳1 还剩下n-1阶  记作 G(n-1) 可选
-  // 我tm跳2 还剩下n-2阶  记作 G(n-2) 可选
-  // ....
-  // 我tm跳n-1 还剩下1阶  记作 G(1)   可选
-
-  // 归纳出： G(n-1)=G(1)+G(2)+.....+G(n-2);
-  //         G(n)=G(1)+G(2)+.....+G(n-2)+G(n-1)
+/**
+ * 利用Math函数计算幂
+ * @param number
+ * @returns {number}
+ */
+function jumpFloorIIOne(number) {
+  return Math.pow(2, number - 1)
+}
 
-  // 两个相减  G(n)=2* G(n-1)   去递归 G(1)=1  , G(2)=2 G(3)=2*G(2)=4
 
-  // 开始代码
-  //     return Math.pow(2,number-1)
-  // 位运算
+/**
+ * 利用左移运算
+ * @param number
+ * @returns {number}
+ */
+function jumpFloorIITwo(number) {
   //     return 1<<(number-1)
   return 1 << --number
 }
+
+
+console.log(jumpFloorIIOne(2))
+console.log(jumpFloorIITwo(4))

code/algorithm/剑指/动态规划/fibonacci.js

@@ -1,33 +1,26 @@
-
-## 刷题整理
+# SOLO算法
 
 
 ### 牛客网
 
 面试必刷TOP101：<https://www.nowcoder.com/exam/oj>
 
-#### 链表
-
-- 反转链表
-
-- 链表内指定区间反转
 
+### 算法模型
 
-#### 二分查找/排序
+#### 快速排序
 
+#### 堆排序
 
-#### 二叉树
 
-#### 堆/栈/队列
+### 面试必刷101
 
-#### 哈希
 
-#### 递归/回溯
+### 剑指Offer
 
-#### 动态规划
 
 
-#### 字符串
+### 参考资料
 
-## 剑指Offer
+- <https://github.com/jiajunhua/labuladong-fucking-algorithm>