feat: 新增笔记

Author: 钟辉

course/course-05-01/linked-list.js

@@ -13,12 +13,12 @@ c.next = d;
 
 /** 遍历链表: 定义一个变量等于链表表头，在表头有值的情况下，不断将变量指向当前链表元素的下一个元素 */
 
-// let p = a;
+let p = a;
 
-// while (p) {
-//   console.log(p.val);
-//   p = p.next;
-// }
+while (p) {
+  console.log(p.val);
+  p = p.next;
+}
 
 /** 插入元素 */
 
@@ -41,14 +41,14 @@ c.next = d;
  *
  */
 
-const tmp = c.next;
-c.next = b;
-b.next = tmp;
-a.next = c;
+// const tmp = c.next;
+// c.next = b;
+// b.next = tmp;
+// a.next = c;
 
-let p = a;
+// let p = a;
 
-while (p) {
-  console.log(p.val);
-  p = p.next;
-}
+// while (p) {
+//   console.log(p.val);
+//   p = p.next;
+// }

course/course-06-01/set.js

@@ -0,0 +1,16 @@
+// 去重复
+const arr = [1, 2, 3, 2, 1, 4, 5];
+
+/** Array.from 配合Set给数组去重 */
+const arr2 = Array.from(new Set(arr));
+/** 解构 配合Set给数组去重 */
+const arr3 = [...new Set(arr)];
+
+// 判断某元素是否在集合中
+const set = new Set(arr);
+const has = set.has(6); /** false */
+
+// 求交集
+const set2 = new Set([2, 3, 4]);
+/** 交集结果 */
+const set3 = new Set([...set].filter((item) => set2.has(item)));

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

@@ -0,0 +1,7 @@
+### 集合简介
+
+#### 一、集合是什么？
+
+1. 集合是一种**无序且唯一**的数据结构；
+2. ES6 中有集合，名为 Set；
+3. 集合常用操作：去重、判断某元素是否在集合中、求交集；

course/course-06-02/set.js

@@ -0,0 +1,8 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersection = function (nums1, nums2) {
+  return [...new Set(nums1)].filter((item) => nums2.includes(item));
+};

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

@@ -0,0 +1,45 @@
+### 6.2 (LeetCode 算法题) 两个数组的交集
+
+#### 1.题目
+
+LeetCode 地址：[两个数组的交集](https://leetcode-cn.com/problems/intersection-of-two-arrays/submissions/)
+
+#### 2. 题目描述
+
+给定两个数组，编写一个函数来计算它们的交集。
+
+示例 1：
+
+```
+输入：nums1 = [1,2,2,1], nums2 = [2,2]
+输出：[2]
+```
+
+示例 2：
+
+```
+输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+输出：[9,4]
+```
+
+说明：
+
+- 输出结果中的每个元素一定是唯一的。
+- 我们可以不考虑输出结果的顺序。
+
+#### 3.解题思路
+
+1. 根据题目描述得到结果是两个数组的交集并且会去重，所以考虑先对数组进行去重处理；
+2. 通过遍历的方式找出某个数组和另一个的相交部分；
+
+#### 4.解题步骤
+
+1. 对第一个数组利用`[...new Set(arr)]`去重复；
+2. 遍历去重后的数组，从另一个数组中筛选出同时存在于另一个数组中的元素；
+
+#### 5. 解题代码（见同级目录文件：set.js）
+
+#### 6. 分析算法的时间复杂度和空间复杂度
+
+1. 时间复杂度：代码中一层循环，所以时间复杂度为 O(n);
+2. 空间复杂度：在执行代码中，把数组转换成了集合然后创建了一个新的数组，使用了一块新的内存空间，所以空间复杂度为 O(n), n 为被去重的数组去重后的长度;

course/course-06-03/set.js

@@ -0,0 +1,57 @@
+let mySet = new Set();
+
+mySet.add(1);
+mySet.add(2);
+mySet.add(2);
+mySet.add("hello world");
+mySet.add("hello world");
+let obj1 = { a: 1 };
+mySet.add(obj1);
+mySet.add(obj1);
+mySet.add({ a: 1 }); // 不会去重，对象{ a: 1 }和obj1内存地址不同
+
+/** 总结： 集合会对添加的相同元素进行去重，其中数值相同但是存储空间不同的对象被认为是不同值，不会被去重 */
+
+/** has()方法判断set是否包含该元素 */
+mySet.has(obj1);
+mySet.has(1);
+
+/** delete()方法删除集合中的元素 */
+mySet.delete(obj1);
+
+/** 遍历集合: 集合的key和value值是相同的 */
+
+for (const item of mySet) {
+  console.log(item);
+}
+
+for (const item of mySet.keys()) {
+  console.log(item);
+}
+
+for (const item of mySet.values()) {
+  console.log(item);
+}
+
+for (const [key, value] of mySet.entries()) {
+  console.log(key, value);
+}
+
+/** Set转换成array */
+
+const myArr1 = [...mySet];
+const myArr2 = Array.from(mySet);
+
+/** Array转换成Set */
+
+const mySet2 = new Set([1, 3, 4, 5]);
+
+/** 求集合交集 */
+function intersection(set1, set2) {
+  return new Set([...set1].filter((item) => set2.has(item)));
+}
+
+/** 求集合差集: set1里存在而set2中不存在的 */
+function difference(set1, set2) {
+  return new Set([...set1].filter((item) => !set2.has(item)));
+}

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

@@ -0,0 +1,6 @@
+### 6.3 前端与集合： 使用 ES6 中的 Set
+
+#### 一、Set 操作
+
+- 使用 Set 对象： new、add、 delete、 has、size
+- 迭代 Set: 多种迭代方法、Set 与 Array 互转、求交集/差集

course/course-07-01/map.js

@@ -0,0 +1,23 @@
+const map1 = new Map();
+
+/** 新增键值对 */
+map1.set("name", "张三");
+map1.set({ name: "张三" }, "张三");
+
+/** 根据键名获取值 */
+const name = map1.get("name");
+console.log("name", name);
+const name2 = map1.get({ name: "张三" });
+/** 输出undefined，因为传入的对象{ name: "张三" }和开始设置的对象内存空间不同，
+ * 无法获取到开始设置的键名对应的值 */
+console.log("name2", name);
+
+/** 删除键值对 */
+/** 删除单个 */
+map1.delete("name");
+/** 删除所有 */
+map1.clear();
+
+/** 修改键值对的值 */
+map1.set("name", "李四");
+map1.set("name", "王五");

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

@@ -0,0 +1,25 @@
+### 字典简介
+
+#### 一、字典是什么？
+
+- 字典，ES6 中有与之对应的数据类型就是 Map；
+- 字典也是一种存储唯一值的数据结构，使用`键值对`的形式存储；
+- 字典的常用操作：键值对的增删改查；
+
+#### 二、ES6 中的 Map
+
+##### 1. Objects 于 Maps 的比较
+
+Maps 和 Objects 类似，都允许存储键值对，但是它们仍旧有一些不同点。
+
+1. Objects 的键（key）只允许是整数(不能通过.语法访问，只能通过 obj[key]访问)、字符串和 symbol，Maps 的键（key）支持 Javascript 中的所有类型，也就是说 Maps 的键可以是数组或者对象；
+
+2. Objects 中的键名可能和对象原型上的键名冲突，Maps 默认不包含任何键；
+
+3. Maps 元素的顺序严格遵循插入的顺序，Objects 没有这一特性；
+
+4. Maps 可以通过 size 属性获取键值对的个数，对象需要通过方法获取键的个数，如：Object.keys(obj).length；
+
+5. Maps 本身就是可迭代的（`iterable`），可以直接被迭代，使用 for of 语法即可，但是 Objects 本身不是可迭代的，需要使用 for in（for of 只能迭代`iterable`）;
+
+6. 频繁增删键值对的场景，Maps 表现更好；

course/course-07-02/map.js

@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersection = function (nums1, nums2) {
+  const map1 = new Map();
+  nums1.forEach((item) => {
+    map1.set(item, true);
+  });
+  const result = [];
+  nums2.forEach((item) => {
+    if (map1.has(item)) {
+      result.push(item);
+      map1.delete(item);
+    }
+  });
+  return result;
+};
+
+/**
+ *
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersection1 = function (nums1, nums2) {
+  /** 利用Map的键名唯一性，对数组进行去重 */
+  const map1 = new Map();
+  nums1.forEach((item) => {
+    map1.set(item, true);
+  });
+  const map2 = new Map();
+  nums2.forEach((item) => {
+    map2.set(item, true);
+  });
+  const result = [];
+  /** 遍历Map，获取交集 */
+  for (const key of map2.keys()) {
+    if (map1.has(key)) {
+      result.push(key);
+    }
+  }
+  return result;
+};
+
+/**
+ * 缺点，创建了2个map，消耗内存空间大
+ * 优点，简单容易理解
+ */