1.. - 力扣（LeetCode）

这题用到了map和栈的知识点

我们利用map的特性，将（）【】{}，分别一一对应

然后遍历，如果map（char）为真，就意味着是左边的部分（【{，将其入栈
然后如果map（char）不为真，意味着是右边的部分）】}，我们就进行判断，如果map（char）=现在栈顶的元素stack.pop()，就返回真，不然报错

/*** @param {string} s* @return {boolean}*/
var isValid = function(s) {const stack=[];const map={'(':')','[':']','{':'}'};for(let i=0;i<s.length;i++){const char=s[i];if(map[char]){stack.push(char);}else{const top=stack.pop();if(map[top]!=char){return false}}}return stack.length===0;
};
const s='()[]{}'
console.log(isValid(s))

2.. - 力扣（LeetCode）

二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为“左子节点”和“右子节点”。

前序遍历是一种遍历二叉树的方式，其顺序如下：

1. 访问根节点。
2. 前序遍历左子树。
3. 前序遍历右子树。

 这个题首先你得手动构建一下二叉树结构，然后写一个方法将数组变为二叉树结构

最后用入栈和出栈实现

var TreeNode = /** @class */ (function () {function TreeNode(val, left, right) {if (val === void 0) { val = 0; }if (left === void 0) { left = null; }if (right === void 0) { right = null; }this.val = val;this.left = left;this.right = right;}return TreeNode;
}());
var buildTree = function (arr, index) {if (index === void 0) { index = 0; }if (index >= arr.length || arr[index] === null) {return null;}var node = new TreeNode(arr[index]);node.left = buildTree(arr, 2 * index + 1);node.right = buildTree(arr, 2 * index + 2);return node;
};
var preorderTraversal = function (root) {var res = [];if (!root)return res;var stack = [root];while (stack.length !== 0) {var node = stack.pop();if (node) {res.push(node.val);if (node.right) {stack.push(node.right);}if (node.left) {stack.push(node.left);}}}return res;
};
var rootArray = [1, null, 2, 3];
var root = buildTree(rootArray);
console.log(preorderTraversal(root)); // 输出: [1, 2, 3]

3.. - 力扣（LeetCode）

这个题很简单

• this.queue.push(t)：将当前请求的时间戳 t 添加到队列 queue 中。
• while (this.queue[0] < t - 3000)：当队列中最早的请求时间小于当前时间 t 减去 3000 毫秒时，将其从队列中移除。这一步保证了队列中只保留最近 3000 毫秒内的请求。

var RecentCounter = function() {this.queue = [];
};RecentCounter.prototype.ping = function(t) {this.queue.push(t);while (this.queue[0] < t - 3000) {this.queue.shift();}return this.queue.length;
};

 4.. - 力扣（LeetCode）

 

例如，给定链表 4→5→1→9，要被删除的节点是 5，即链表中的第 2 个节点。可以通过如下两步操作实现删除节点的操作。

将第 2 个节点的值修改为第 3 个节点的值，即将节点 5 的值修改为 1，此时链表如下：
4→1→1→9
删除第 3 个节点，此时链表如下：
4→1→9

var deleteNode = function(node) {node.val = node.next.val;node.next = node.next.next;
};

5.. - 力扣（LeetCode）

在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

var reverseList = function(head) {let prev = null;let curr = head;while (curr) {const next = curr.next;curr.next = prev;prev = curr;curr = next;}return prev;
};

6.. - 力扣（LeetCode）

这里要考虑是进位值

由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。

我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 ⌊ 
10
n1+n2+carry

如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。

此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。

 

var addTwoNumbers = function(l1, l2) {let head = null, tail = null;let carry = 0;while (l1 || l2) {const n1 = l1 ? l1.val : 0;const n2 = l2 ? l2.val : 0;const sum = n1 + n2 + carry;if (!head) {head = tail = new ListNode(sum % 10);} else {tail.next = new ListNode(sum % 10);tail = tail.next;}carry = Math.floor(sum / 10);if (l1) {l1 = l1.next;}if (l2) {l2 = l2.next;}}if (carry > 0) {tail.next = new ListNode(carry);}return head;
};

7.跳转提示-稀土掘金

细节

当我们遍历到链表的最后一个节点时，cur.next 为空节点，如果不加以判断，访问 cur.next 对应的元素会产生运行错误。因此我们只需要遍历到链表的最后一个节点，而不需要遍历完整个链表。

var deleteDuplicates = function(head) {if (!head) {return head;}let cur = head;while (cur.next) {if (cur.val === cur.next.val) {cur.next = cur.next.next;} else {cur = cur.next;}}return head;
};

 8.. - 力扣（LeetCode）

var hasCycle = function (head) {let slow = head, fast = head; // 乌龟和兔子同时从起点出发while (fast && fast.next) {slow = slow.next; // 乌龟走一步fast = fast.next.next; // 兔子走两步if (fast === slow) // 兔子追上乌龟（套圈），说明有环return true;}return false; // 访问到了链表末尾，无环
};

 9.. - 力扣（LeetCode）

 hash的办法

哈希集合（HashSet）是一种基于哈希表的数据结构，主要用于存储不重复的元素。它允许以常数时间复杂度（O(1)）进行添加、删除和查找操作。JavaScript 中没有直接的 HashSet 实现，但我们可以使用 Set 对象来实现类似的功能。

function intersection(nums1, nums2) {let result = [];let hash = {};// 填充哈希表for (const num of nums1) {hash[num] = 1;}// 查找交集并更新结果for (const num of nums2) {if (hash[num]) {result.push(num);hash[num] = 0; // 确保每个元素只添加一次}}return result;
}// 测试用例
const nums1 = [1, 2, 2, 1];
const nums2 = [2, 2];
console.log(intersection(nums1, nums2)); // 输出: [2]const nums3 = [4, 9, 5];
const nums4 = [9, 4, 9, 8, 4];
console.log(intersection(nums3, nums4)); // 输出: [4, 9]