这题用到了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))
二叉树是一种树形数据结构,其中每个节点最多有两个子节点,通常称为“左子节点”和“右子节点”。
前序遍历是一种遍历二叉树的方式,其顺序如下:
- 访问根节点。
- 前序遍历左子树。
- 前序遍历右子树。
这个题首先你得手动构建一下二叉树结构,然后写一个方法将数组变为二叉树结构
最后用入栈和出栈实现
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]
这个题很简单
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→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;
};
在遍历链表时,将当前节点的 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;
};
这里要考虑是进位值
由于输入的两个链表都是逆序存储数字的位数的,因此两个链表中同一位置的数字可以直接相加。
我们同时遍历两个链表,逐位计算它们的和,并与当前位置的进位值相加。具体而言,如果当前两个链表处相应位置的数字为 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;
};
细节
当我们遍历到链表的最后一个节点时,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;
};
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; // 访问到了链表末尾,无环
};
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]