feat: 新增笔记

Author: programmermark

.DS_Store

@@ -0,0 +1,3 @@
+{
+  "liveServer.settings.port": 5501
+}

.vscode/settings.json

@@ -0,0 +1,5 @@
+const queue = [];
+queue.push(100);
+queue.push(200);
+const item1 = queue.shift();
+const item2 = queue.shift();

course/course-04-01/queue.js

@@ -0,0 +1,7 @@
+### 4.1 队列简介
+
+#### 一、队列是什么？
+
+> 队列是一个`先进先出`的数据结构。
+
+> Javascript 中没有队列，但可以用 Array 实现队列的所有功能。

course/course-04-01/笔记.md

@@ -0,0 +1,36 @@
+### 4.2 什么场景用队列
+
+> 一、需要先进先出的场景用队列
+
+#### 场景一、食堂排队打饭可以使用队列
+
+#### 场景二、JS 异步中的任务队列
+
+1. JS 是单线程，无法同时处理异步中的并发任务；
+2. 使用任务队列先后处理异步任务；
+
+#### 场景三、计算最近请求次数（算法题）
+
+##### 1. 题目描述
+
+```
+获取3000毫秒内的最近的请求次数
+
+输入：
+["RecentCounter", "ping", "ping", "ping", "ping"]
+[[], [1], [100], [3001], [3002]]
+输出：
+[null, 1, 2, 3, 3]
+
+解释：
+RecentCounter recentCounter = new RecentCounter();
+recentCounter.ping(1);     // requests = [1]，范围是 [-2999,1]，返回 1
+recentCounter.ping(100);   // requests = [1, 100]，范围是 [-2900,100]，返回 2
+recentCounter.ping(3001);  // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
+recentCounter.ping(3002);  // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3
+```
+
+##### 2. 解题思路
+
+1. 有新请求就入队，3000ms 前发出的请求出队；
+2. 队列的长度就是最近请求次数；

course/course-04-02/笔记.md

@@ -0,0 +1,16 @@
+const RecentCounter = function () {
+  this.q = [];
+};
+
+/**
+ * @param {number} t
+ * @return {number}
+ */
+RecentCounter.prototype.ping = function (t) {
+  this.q.push(t);
+  while (this.q[0] < t - 3000) {
+    this.q.shift();
+  }
+
+  return this.q.length;
+};

course/course-04-03/queue.js

@@ -0,0 +1,56 @@
+### 4.3 (leetCode 算法题) 最近的请求次数
+
+#### 1. 题目 LeetCode 地址：[最近的请求次数](https://leetcode-cn.com/problems/number-of-recent-calls/)
+
+#### 2. 题目描述
+
+写一个  RecentCounter  类来计算特定时间范围内最近的请求。
+
+请你实现 RecentCounter 类：
+
+RecentCounter() 初始化计数器，请求数为 0 。
+int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
+保证 每次对 ping 的调用都使用比之前更大的 t 值。
+
+示例：
+
+```
+输入：
+["RecentCounter", "ping", "ping", "ping", "ping"]
+[[], [1], [100], [3001], [3002]]
+输出：
+[null, 1, 2, 3, 3]
+
+解释：
+RecentCounter recentCounter = new RecentCounter();
+recentCounter.ping(1);     // requests = [1]，范围是 [-2999,1]，返回 1
+recentCounter.ping(100);   // requests = [1, 100]，范围是 [-2900,100]，返回 2
+recentCounter.ping(3001);  // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
+recentCounter.ping(3002);  // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3
+```
+
+提示：
+
+1 <= t <= 109
+保证每次对 ping 调用所使用的 t 值都 严格递增
+至多调用 ping 方法 104 次
+
+#### 3. 解题思路
+
+1. 题目的实际含义是，返回数组中每一次输入 3000 范围内的数量，如：输入 3001，数组中 3001 在 3000 范围内的元素包括：1、100、3001，所以 3000 范围内的数量为 3；
+2. 通过题目描述的示例可以看出，发出的请求越早，越不在最近 3000ms 内的请求里；
+3. 根据队列先进先出的特性，把每一次请求入队，不在 3000ms 内的请求出队，统计队列的长度就可以得到最近请求次数；
+
+#### 4. 解题步骤
+
+1. 新建一个队列用于存放每一次输入的元素；
+2. 把每一次请求入队；
+3. 遍历队列，把超出 3000ms 的请求出队；
+4. 返回队列的长度；
+
+#### 5. 解题代码（见同级目录文件：queue.js）
+
+#### 6. 分析算法的时间复杂度和空间复杂度
+
+1. 时间复杂度：queue.js 中仅有一个 while 循环，所以时间复杂度为 O(n);
+2. 空间复杂度：queue.js 中，遍历的所有元素都可能存储在队列中，所以空间复杂度最大为 O(n);

course/course-04-03/笔记.md

@@ -1,65 +1,98 @@
 <script>
-  /** 时间复杂度O(1) */
-  function fnO1() {
-    console.log("时间复杂度O(1)");
+  // /** 时间复杂度O(1) */
+  // function fnO1() {
+  //   console.log("时间复杂度O(1)");
 
-    const a = 5;
-    const b = 10;
-    const sum = a + b;
-  }
+  //   const a = 5;
+  //   const b = 10;
+  //   const sum = a + b;
+  // }
 
-  /** 时间复杂度 O(logn)、 O(nlogn) */
+  // /** 时间复杂度 O(logn)、 O(nlogn) */
 
-  function fnOlogn(n) {
-    console.log("时间复杂度O(logn)");
+  // function fnOlogn(n) {
+  //   console.log("时间复杂度O(logn)");
 
-    let count = 0;
-    let i = 1;
-    while (i < n) {
-      i = i * 2;
-      count++;
-    }
+  //   let count = 0;
+  //   let i = 1;
+  //   while (i < n) {
+  //     i = i * 2;
+  //     count++;
+  //   }
 
-    console.log("时间复杂度O(logn), 执行次数count: ", count);
-  }
+  //   console.log("时间复杂度O(logn), 执行次数count: ", count);
+  // }
 
-  function fnOnlogn(n) {
-    console.log("时间复杂度O(nlogn)");
-    let count = 0;
-    for (let j = 0; j < n; j++) {
-      let i = 1;
-      while (i < n) {
-        i = i * 2;
-        count++;
-      }
-    }
-    console.log("时间复杂度O(nlogn), 执行次数count: ", count);
-  }
+  // function fnOnlogn(n) {
+  //   console.log("时间复杂度O(nlogn)");
+  //   let count = 0;
+  //   for (let j = 0; j < n; j++) {
+  //     let i = 1;
+  //     while (i < n) {
+  //       i = i * 2;
+  //       count++;
+  //     }
+  //   }
+  //   console.log("时间复杂度O(nlogn), 执行次数count: ", count);
+  // }
 
-  /** 时间复杂度 fnO(m+n), 当可以确认n >= m的时候，时间复杂度可以修改为 O(n) */
+  // /** 时间复杂度 fnO(m+n), 当可以确认n >= m的时候，时间复杂度可以修改为 O(n) */
 
-  function fnOmn1(m, n) {
-    let countM = 0;
-    let countN = 0;
-    for (let i = 0; i < m; i++) {
-      countM += 1;
-    }
-    for (let j = 0; j < n; j++) {
-      countN += 1;
-    }
+  // function fnOmn1(m, n) {
+  //   let countM = 0;
+  //   let countN = 0;
+  //   for (let i = 0; i < m; i++) {
+  //     countM += 1;
+  //   }
+  //   for (let j = 0; j < n; j++) {
+  //     countN += 1;
+  //   }
 
-    console.log("时间复杂度O(m+n)，执行次数count: ", countM + countN);
+  //   console.log("时间复杂度O(m+n)，执行次数count: ", countM + countN);
+  // }
+
+  // /** 时间复杂度 fnO(m*n), 当可以确认n >= m的时候，时间复杂度可以修改为 O(n^2) */
+  // function fnOmn2(m, n) {
+  //   let count = 0;
+  //   for (let i = 0; i < m; i++) {
+  //     for (let j = 0; j < n; j++) {
+  //       count += 1;
+  //     }
+  //   }
+
+  //   console.log("时间复杂度O(m*n)，执行次数count: ", count);
+  // }
+
+  function array2List(arr, type = 0) {
+    if (!arr.length) return null;
+    let header = { data: arr[0], next: null };
+    let obj = header;
+    for (let i = 1; i < arr.length; i++) {
+      obj.next = { data: arr[i], next: null };
+      obj = obj.next;
+    }
+    if (type) obj.next = header;
+    return header;
   }
 
-  /** 时间复杂度 fnO(m*n), 当可以确认n >= m的时候，时间复杂度可以修改为 O(n^2) */
-  function fnOmn2(m, n) {
-    let count = 0;
-    for (let i = 0; i < m; i++) {
-      for (let j = 0; j < n; j++) {
-        count += 1;
-      }
+  var list = array2List([1, 2, 3, 4, 5]);
+  console.log(list);
+
+  var reverseList = function (head) {
+    console.log(head);
+    let p1 = head;
+    let p2 = null;
+    while (p1) {
+      const tmp = p1.next;
+      p1.next = p2;
+      p2 = p1;
+      p1 = tmp;
+      // p2 = p1;
+      // p1 = p1.next;
     }
+    return p2;
+  };
 
-    console.log("时间复杂度O(m*n)，执行次数count: ", count);
-  }
+  var result = reverseList(list);
+  console.log(result);
 </script>

demo/1.时间复杂度-demo.html

@@ -0,0 +1,66 @@
+// /** 模拟链表 */
+
+// const a = { val: "a" };
+// const b = { val: "b" };
+// const c = { val: "c" };
+// const d = { val: "d" };
+// const e = { val: "e" };
+
+// /** 创建链表 */
+// a.next = b;
+// b.next = c;
+// c.next = d;
+// d.next = e;
+
+// /** 插入元素 */
+// const f = { val: "f" };
+// c.next = f;
+// f.next = d;
+
+// /** 删除元素 */
+// b.next = f;
+
+// /** 遍历链表 */
+// let p = a;
+// while (p) {
+//   console.log(p.val);
+//   p = p.next;
+// }
+
+// function ListNode(val, next) {
+//   this.val = val === undefined ? 0 : val;
+//   this.next = next === undefined ? null : next;
+// }
+
+// function arrayToLinkedList(array) {
+//   if (!Array.isArray(array)) {
+//     return '传入的参数必须是数组'
+//   } else if (array.length = 0) {
+//     return "传入的参数必须是数组长度不能为0";
+//   } else {
+//     let nodeList = {val: array[0]};
+//     let length = array.length
+//     while (length) {
+//       const node = {
+//         val: array[1],
+//       }
+//       nodeList.next = node;
+//       array.shift();
+//     }
+//   }
+// }
+
+function array2List(arr, type = 0) {
+  if (!arr.length) return null;
+  let header = { data: arr[0], next: null };
+  let obj = header;
+  for (let i = 1; i < arr.length; i++) {
+    obj.next = { data: arr[i], next: null };
+    obj = obj.next;
+  }
+  if (type) obj.next = header;
+  return header;
+}
+
+var list = array2List([1, 2, 3, 4]);
+console.log(list);