leetcode刷题（javaScript）——堆相关场景题总结

已于 2024-03-14 13:43:12 修改
阅读量980 收藏 24
点赞数 18
分类专栏： Leetcode刷题技巧总结 文章标签： leetcode 算法 职场和发展
于 2024-03-13 14:58:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36384657/article/details/136655772
版权

堆是什么？堆都能用树表示，并且一般树的实现都是利用链表。平时使用的最多的是二叉堆，它可以用完全二叉树表示，二叉堆易于存储，并且便于索引。在堆的实现时注意：因为是数组，所以父子节点的关系就不需要特殊的结构去维护了，索引之前通过计算就可以得到，省掉了很多麻烦，如果是链表结构，就会复杂很多。

在JavaScript刷题中，堆（Heap）通常用于解决一些需要高效处理优先级的问题，例如找出最大或最小的K个元素、实现优先队列等。堆在刷题中的应用场景包括但不限于以下几个方面：

  1. 找出最大或最小的K个元素：通过维护一个大小为K的最大堆或最小堆，可以快速找出数组中最大或最小的K个元素。

  2. 合并K个有序数组：可以使用堆来合并K个有序数组，实现高效的合并操作。

  3. 实现优先队列：堆可以用于实现优先队列，保证队列中优先级高的元素先出队。

 数组存储二叉堆

        二叉堆是一种完全二叉树，分为最小堆和最大堆两种类型。用数组存储二叉堆， 完全二叉树要求叶子节点从左往右填满，才能开始填充下一层。

  1. 二叉堆：二叉堆是一种完全二叉树，通常使用数组来表示。在最小堆中，父节点的值小于或等于其子节点的值；在最大堆中，父节点的值大于或等于其子节点的值。

  2. 最小堆：在最小堆中，父节点的值小于或等于其子节点的值。根节点是堆中的最小值。

  3. 最大堆：在最大堆中，父节点的值大于或等于其子节点的值。根节点是堆中的最大值。

注：完全二叉树和满二叉树不同，完全二叉树允许叶子节点不铺满。

动画演示创建堆的过程

 

同一组数据最小堆和最大堆是唯一的吗？

同一组数据的最小堆或最大堆不是唯一的。以最小堆为例：最小堆是一种特殊的二叉堆，它满足以下两个性质：

  1. 父节点的值小于或等于其子节点的值。
  2. 堆中任意节点的子树也是一个最小堆。

        由于最小堆只要满足上述性质即可，因此对于同一组数据，可以有多种不同的最小堆表示方式。这是因为在构建最小堆的过程中，可以选择不同的节点作为根节点，从而得到不同的堆结构。

所以，同一组数据的最小堆并不是唯一的，可以有多种不同的表示方式。

如何找到节点i父节点和子节点呢？

        二叉堆在数组是按层次遍历进行存储的，从上至下，从左至右。因此子节点的index要大于父节点的index。在二叉堆中，可以通过以下方式计算父节点和子节点的索引：

  • 父节点索引计算：对于节点i，其父节点的索引为(i-1)/2。
  • 左子节点索引计算：对于节点i，其左子节点的索引为2*i+1。
  • 右子节点索引计算：对于节点i，其右子节点的索引为2*i+2。

如何删除节点？

在删除一个元素之后，整体往前移动是比较费时的，这也是随机存储结构的短板。因此，堆在删除元素的时候是把最后一个叶子节点补充到树根节点。在通过节点移动将堆调整为最小堆或最大堆。

如何通过js构建最大堆

首先构造器得有吧，创建一个空的heap数组；

其次将获取父节点index、左右子节点index、堆大小size、栈顶元素获取、两节点交换这些简单的辅助函数写一下；

主函数insert插入节点：每次从heap的尾部也就是最后一个叶子节点插入，插进去的叶子节点得向上找它的位置吧，写一个up方法，找到插入节点位置；

up方法实现：找到节点的父元素，看父元素是否比自己小，如果小的换就交换，并且递归up方法，直到所有元素都调整好。

删除节点pop方法：这里依然将最后节点移到第一个跟节点，此时根节点一定是最小的，不符合最大堆规则，所以调整跟节点向下移动，写一个down方法移动根节点。这里注意堆的size如果等于1直接删除而不用移动节点。

down方法实现：找到根的左右子节点，选择比根大的节点进行交换，并递归down方法，直到所有节点都调整好。

交换节点swap可以使用数组解构进行交换，而不用单独定义中间值。

class MaxHeap {
    constructor() {
        this.heap = [];
    }
    //获取父元素下标
    getParentIndex(index) {
        return Math.floor((index - 1) / 2);
    }
    //获取左子树下标
    getLeftIndex(index) {
        return 2 * index + 1;
    }
    //获取右子树下标
    getRightIndex(index) {
        return 2 * index + 2;
    }
    //获取堆大小
    size() {
        return this.heap.length;
    }
    //获取堆顶元素
    peek() {
        return this.heap[0];
    }
    //交换节点
    swap(id1, id2) {
        [this.heap[id2], this.heap[id1]] = [this.heap[id1], this.heap[id2]];
    }
    //插入节点
    insert(value) {
        this.heap.push(value);
        this.up(this.size() - 1);
    }
    //删除节点
    pop() {
        let last = this.heap.pop();
        if (this.size() === 0) return;
        this.heap[0] = last;
        this.down(0);
    }
    //向上移动节点
    up(index) {
        const parentIndex = this.getParentIndex(index);
        if (this.heap[index] > this.heap[parentIndex]) {
            this.swap(parentIndex, index);
            this.up(parentIndex);
        }
    }
    //向下移动节点
    down(index) {
        const leftIndex = this.getLeftIndex(index);
        const rightIndex = this.getRightIndex(index);
        let smallIndex = index;

        if (
            leftIndex < this.size() &&
            this.heap[leftIndex] > this.heap[smallIndex]
        ) {
            smallIndex = leftIndex;
        }
        if (
            rightIndex < this.size() &&
            this.heap[rightIndex] > this.heap[smallIndex]
        ) {
          smallIndex = rightIndex;
        }
       if (smallIndex != index) {
           this.swap(smallIndex, index);
           this.down(smallIndex);
       }
    }
}

 这里让根节点从左右节点中与最小的节点进行交换。注意减少交换次数，避免多次递归

如何通过js构建最小堆

与创建最小堆类似。创建堆，往堆里新增元素，删除堆顶，获取堆的父节点下标，获取堆左右子节点下标

 代码示例

class MinHeap {
  constructor() {
    this.heap = [];
  }
  getParentIndex(index) {
    return Math.floor((index - 1) / 2);
  }
  getLeftIndex(index) {
    return index * 2 + 1;
  }
  getRightIndex(index) {
    return index * 2 + 2;
  }
  swap(i1, i2) {
    [this.heap[i1], this.heap[i2]] = [this.heap[i2], this.heap[i1]];
  }
  //往堆最后添加节点，触发元素上移
  //当前元素与其跟节点进行比较如果大于其跟节点与根节点进行交换，重复操作
  up(index) {
    //如果是0就不移动
    if (index == 0) return;
    //获取父元素
    const parentIndex = this.getParentIndex(index);
    if (this.heap[parentIndex] > this.heap[index]) {
      this.swap(parentIndex, index);
      //对交换后parentIndex继续向上递归
      this.up(parentIndex);
    }
  }
  //从堆顶删除元素时，将子节点移到堆顶，触发元素下移
  down(index) {
    const leftIndex = this.getLeftIndex(index);
    const rightIndex = this.getRightIndex(index);
    let smallIndex = index;
    //左子树小于根节点，交换左子树与根
    if (
      leftIndex < this.size() &&
      this.heap[leftIndex] < this.heap[smallIndex]
    ) {
      smallIndex = leftIndex;
    }
    //同理，右子树小于根节点，交换右子树与根
    if (
      rightIndex < this.size() &&
      this.heap[rightIndex] < this.heap[smallIndex]
    ) {
      smallIndex = rightIndex;
    }
    if (smallIndex != index) {
      this.swap(smallIndex, index);
      this.down(smallIndex);
    }
  }

  //往堆里增加元素
  insert(value) {
    this.heap.push(value);
    this.up(this.heap.length - 1);
  }
  //将堆顶元素弹出
  //删除节点
  pop() {
    let last = this.heap.pop();
    if (this.size() === 0) return;
    this.heap[0] = last;
    this.down(0);
  }

  //获取堆顶
  peek() {
    return this.heap[0];
  }
  //获取堆大小
  size() {
    return this.heap.length;
  }
}

 215. 数组中的第K个最大元素

解决数组中的第K个最大元素问题时，通常使用最小堆来实现。通过维护一个大小为K的最小堆，可以在O(NlogK)的时间复杂度内找到数组中的第K个最大元素。

但是题目最近新增了一个要求：就是必须让算法的时间复杂度控制在O(n)，当K很大时使用堆有可能会超出时间复杂度，所以要减少不必要的交换移动。

直到今天（2024.3.14）使用堆排序仍然可以跑通全部案例。

注：官方给的快速选择，甚至是"三数取中"的方法来选择基准值也都无法达到时间复杂度，会在第40/41个案例卡住。

使用最小堆获取数组中第K个最大元素的思路：

  1. 初始化一个大小为K的最小堆：将数组中的前K个元素放入最小堆中。

  2. 遍历数组剩余元素：从第K+1个元素开始遍历数组，对于每个元素，如果大于最小堆的堆顶元素（堆中最小的元素），则将该元素加入最小堆，并移除堆顶元素。

  3. 返回堆顶元素：遍历完成后，最小堆的堆顶元素即为数组中的第K个最大元素。

使用最小堆的优势在于可以保持堆的大小为K，只需维护K个元素，避免了对整个数组进行排序或维护大堆的复杂度。

class MinHeap {
    constructor() {
        this.heap = [];
    }
    getParentIndex(index) {
        return Math.floor((index - 1) / 2);
    }
    getLeftIndex(index) {
        return index * 2 + 1;
    }
    getRightIndex(index) {
        return index * 2 + 2;
    }
    swap(i1, i2) {
        [this.heap[i1], this.heap[i2]] = [this.heap[i2], this.heap[i1]];
    }
    //往堆最后添加节点，触发元素上移
    //当前元素与其跟节点进行比较如果大于其跟节点与根节点进行交换，重复操作
    up(index) {
        //如果是0就不移动
        if (index == 0) return;
        //获取父元素
        const parentIndex = this.getParentIndex(index);
        if (this.heap[parentIndex] > this.heap[index]) {
            this.swap(parentIndex, index);
            //对交换后parentIndex继续向上递归
            this.up(parentIndex);
        }
    }
    //从堆顶删除元素时，将子节点移到堆顶，触发元素下移
    down(index) {
        const leftIndex = this.getLeftIndex(index);
        const rightIndex = this.getRightIndex(index);
        let smallIndex = index;
        //左子树小于根节点，交换左子树与根
        if (leftIndex < this.size() && this.heap[leftIndex] < this.heap[smallIndex]) {
            smallIndex = leftIndex;
        }
        //同理，右子树小于根节点，交换右子树与根
        if (rightIndex < this.size() && this.heap[rightIndex] < this.heap[smallIndex]) {
            smallIndex = rightIndex;
        }
        if (smallIndex != index) {
            this.swap(smallIndex, index);
            this.down(smallIndex);
        }
    }

    //往堆里增加元素
    insert(value) {
        this.heap.push(value);
        this.up(this.heap.length - 1);
    }
    //将堆顶元素弹出
    //删除节点
    pop() {
        let last = this.heap.pop();
        if (this.size() === 0) return;
        this.heap[0] = last;
        this.down(0);
    }

    //获取堆顶
    peek() {
        return this.heap[0];
    }
    //获取堆大小
    size() {
        return this.heap.length;
    }
}
// 寻找第 k 个最大的元素
var findKthLargest = function (nums, k) {
    let minHeap = new MinHeap();
    nums.forEach(item => {
        minHeap.insert(item);
        if (minHeap.size() > k) {
            //每次pop的是栈顶，及k+1个元素中最小的
            minHeap.pop();
        }
    })
    return minHeap.peek();
};

 算法可以通过全部的41个测试用例

 703. 数据流中的第 K 大元素

设计一个找到数据流中第 k 大元素的类（class）。注意是排序后的第 k 大元素，不是第 k 个不同的元素。

请实现 KthLargest 类：

  • KthLargest(int k, int[] nums) 使用整数 k 和整数流 nums 初始化对象。
  • int add(int val) 将 val 插入数据流 nums 后，返回当前数据流中第 k 大的元素。

 思路：也是用最小堆来实现，最小堆前面已经介绍过堆的插入删除，直接将创建堆对象的类拿来用即可。

动态构建一个长度为k的最小堆，对顶即第k大的的元素。因为比k小的元素都被pop出去了

/**
 * @param {number} k
 * @param {number[]} nums
 */
var KthLargest = function (k, nums) {
    //构建一个k个长度的最小堆
    this.k = k;
    this.minHeap = new MinHeap();

    // 初始化最小堆
    for (let num of nums) {
        this.add(num);
    }
};

/** 
 * @param {number} val
 * @return {number}
 */
KthLargest.prototype.add = function (val) {
    this.minHeap.insert(val);
    while (this.minHeap.size() > this.k) {
        this.minHeap.pop();
    }
    return this.minHeap.peek();
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * var obj = new KthLargest(k, nums)
 * var param_1 = obj.add(val)
 */
class MinHeap {
  constructor() {
    this.heap = [];
  }
  getParentIndex(index) {
    return Math.floor((index - 1) / 2);
  }
  getLeftIndex(index) {
    return index * 2 + 1;
  }
  getRightIndex(index) {
    return index * 2 + 2;
  }
  swap(i1, i2) {
    [this.heap[i1], this.heap[i2]] = [this.heap[i2], this.heap[i1]];
  }
  //往堆最后添加节点，触发元素上移
  //当前元素与其跟节点进行比较如果大于其跟节点与根节点进行交换，重复操作
  up(index) {
    //如果是0就不移动
    if (index == 0) return;
    //获取父元素
    const parentIndex = this.getParentIndex(index);
    if (this.heap[parentIndex] > this.heap[index]) {
      this.swap(parentIndex, index);
      //对交换后parentIndex继续向上递归
      this.up(parentIndex);
    }
  }
  //从堆顶删除元素时，将子节点移到堆顶，触发元素下移
  down(index) {
    const leftIndex = this.getLeftIndex(index);
    const rightIndex = this.getRightIndex(index);
    let smallIndex = index;
    //左子树小于根节点，交换左子树与根
    if (
      leftIndex < this.size() &&
      this.heap[leftIndex] < this.heap[smallIndex]
    ) {
      smallIndex = leftIndex;
    }
    //同理，右子树小于根节点，交换右子树与根
    if (
      rightIndex < this.size() &&
      this.heap[rightIndex] < this.heap[smallIndex]
    ) {
      smallIndex = rightIndex;
    }
    if (smallIndex != index) {
      this.swap(smallIndex, index);
      this.down(smallIndex);
    }
  }

  //往堆里增加元素
  insert(value) {
    this.heap.push(value);
    this.up(this.heap.length - 1);
  }
  //将堆顶元素弹出
  //删除节点
  pop() {
    let last = this.heap.pop();
    if (this.size() === 0) return;
    this.heap[0] = last;
    this.down(0);
  }

  //获取堆顶
  peek() {
    return this.heap[0];
  }
  //获取堆大小
  size() {
    return this.heap.length;
  }
}

 1046. 最后一块石头的重量

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

  • 如果 x == y，那么两块石头都会被完全粉碎；
  • 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

 思想：构建一个最大堆，从堆顶取两个值分别为y,x判断如果y>x则将y-x放入堆中并将堆调整为最大堆。递归直到堆长度小于2。如果堆里还有值则返回堆顶元素，否则为0

/**
 * @param {number[]} stones
 * @return {number}
 */
var lastStoneWeight = function (stones) {
    if (stones.length == 1) return stones[0];
    let maxHeap = new MaxHeap();
    stones.forEach((item) => maxHeap.insert(item));
    while (maxHeap.size() > 1) {
        let y = maxHeap.peek();
        maxHeap.pop();
        let x = maxHeap.peek();
        maxHeap.pop();
        if (y > x) {
            maxHeap.insert(y - x);
        }
    }
    return maxHeap.size() ? maxHeap.peek() : 0;
};
/**
 * @param {number[]} stones
 * @return {number}
 */
var lastStoneWeight = function (stones) {
    if (stones.length == 1) return stones[0];
    let maxHeap = new MaxHeap();
    stones.forEach((item) => maxHeap.insert(item));
    while (maxHeap.size() > 1) {
        let y = maxHeap.peek();
        maxHeap.pop();
        let x = maxHeap.peek();
        maxHeap.pop();
        if (y > x) {
            maxHeap.insert(y - x);
        }
    }
    return maxHeap.size() ? maxHeap.peek() : 0;
};
class MaxHeap {
    constructor() {
        this.heap = [];
    }
    //获取父元素下标
    getParentIndex(index) {
        return Math.floor((index - 1) / 2);
    }
    //获取左子树下标
    getLeftIndex(index) {
        return 2 * index + 1;
    }
    //获取右子树下标
    getRightIndex(index) {
        return 2 * index + 2;
    }
    //获取堆大小
    size() {
        return this.heap.length;
    }
    //获取堆顶元素
    peek() {
        return this.heap[0];
    }
    //交换节点
    swap(id1, id2) {
        [this.heap[id2], this.heap[id1]] = [this.heap[id1], this.heap[id2]];
    }
    //插入节点
    insert(value) {
        this.heap.push(value);
        this.up(this.size() - 1);
    }
    //删除节点
    pop() {
        let last = this.heap.pop();
        if (this.size() === 0) return;
        this.heap[0] = last;
        this.down(0);
    }
    //向上移动节点
    up(index) {
        const parentIndex = this.getParentIndex(index);
        if (this.heap[index] > this.heap[parentIndex]) {
            this.swap(parentIndex, index);
            this.up(parentIndex);
        }
    }
    //向下移动节点
    down(index) {
        const leftIndex = this.getLeftIndex(index);
        const rightIndex = this.getRightIndex(index);
        let smallIndex = index;

        if (
            leftIndex < this.size() &&
            this.heap[leftIndex] > this.heap[smallIndex]
        ) {
            smallIndex = leftIndex;
        }
        if (
            rightIndex < this.size() &&
            this.heap[rightIndex] > this.heap[smallIndex]
        ) {
          smallIndex = rightIndex;
        }
       if (smallIndex != index) {
           this.swap(smallIndex, index);
           this.down(smallIndex);
       }
    }
}

三月的一天
关注
  • 18
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
用Js怒刷LeetCode
m0_67615103的博客
02-21 456
以上题目均为精选高频题，希望对大家有帮助.
leetcode JS实现
ice2spring的博客
09-01 661
763  partition labels 输入: S = "ababcbacadefegdehijhklij" 输出: [9,7,8] 解释: 划分结果为 "ababcbaca", "defegde", "hijhklij"。 每个字母最多出现在一个片段中。 像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。  注意: S的长度
js leetcode
Borkes
11-15 570
用js做leetcode的时候用到了递归调用，但是出现了Maximum call stack size exceded 这个栈溢出跟js的默认传参有关系，在这里做一点记录。代码如下，这个时用暴力法直接做正则匹配的题 var match = function(s,p,ss,pp){ if(ss === s.length){ return pp === p.length;
leetcode(js)
王源偷我华子
03-10 203
1.两数之和 /** * @param {number[]} nums * @param {number} target * @return {number[]} */ var twoSum = function(nums, target) { let arr = new Map() for(let i=0;i<nums.length;i++){ let x = target - nums[i] if(!arr.has(nums[i])){
[leetcode]1. Two Sum -- JavaScript 代码
YuqiRealm.com
09-04 1247
[leetcode]1. Two Sum -- JavaScript 代码
LeetCode刷题笔记——#14. 最长公共前缀
12-22
难度：简单 一、题目描述： 二、解题分析： 1、水平扫描 class Solution: def longestCommonPrefix(self, strs: List[str]) -> str: if len(strs) == 0: return '' s = strs[0] for i in range(1, len(strs)): ...
LeetCode刷题笔记——63. 不同路径 II
12-21
【LeetCode刷题笔记——63. 不同路径 II】 一、题目描述： 在LeetCode的第63题中，我们被要求计算一个有障碍物的网格中从左上角到右下角的不同路径数量。网格由一个二维整数数组`obstacleGrid`表示，其中1代表障碍...
LeetCode刷题笔记——56. 合并区间
01-20
难度：中等 一、题目描述： 二、解题分析： 1、解析   1）先对列表进行排序   2）判断两个相邻区间是否有交集 2、代码实现 class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]:...
LeetCode刷题笔记——#66. 加一
12-22
  这道题其实关注点只有一个，那就是进位的问题。设置一个进位位flag，先把最后一位加1，分离出十位和个位。之后依次对前面的数调整。判断最后依次进位位是否为1，如果是就在数组头插入1。 from typing import ...
LeetCode刷题笔记——#70. 爬楼梯
12-22
难度：简单 一、题目描述： 二、解题分析： ...###### leetcode 代码主体 ###### class Solution: def climbStairs(self, n: int) -> int: a, b = 1, 2 for i in range(n - 1): a, b = b, a + b
leetcode中国-LeetCode:LeetCode经典题目分类汇总(JavaScript实现)
06-29
leetcode中国 LeetCode 最近在进行 LeetCode 和力扣中国的每日一题，如果有共同刷题的小伙伴可以点击 一起参与。 我对题目进行了标签分类，你也可以按 进行刷题。 数组 ( Array ) 链表 ( Linked List ) 栈 ( Stack ) 树 ( Tree ) 二叉搜索树 ( BST ) 字典树（前缀树） ( Trie ) 哈希表 ( Hash Table ) 堆 ( Heap ) 图 ( Graph ) 二分查找 ( Binary Search ) 位运算 ( Bit Manipulation ) 分治算法 ( Divide And Conquer ) 排序 ( Sort ) 回溯算法 ( Backtracking ) 双指针 ( Two Pointers ) 滑动窗口 ( Sliding Window ) 动态规划 ( DP ) Kanade ( Kanade ) 前缀和 ( Prefix Sum ) 贪心算法 ( Greedy ) 深度优先搜索 ( DFS ) 广度优先搜索 ( BFS ) 拓扑排序 ( Topological Sort ) Rab
用JavaScript刷LeetCodeOJ解题报告合集
08-11
用 JavaScript 刷 LeetCodeOJ 解题报告合集
2020-11-24每日一题4、寻找两个正序数组的中位数
qq_40310710的博客
11-24 155
寻找两个正序数组的中位数 给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。 进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？ 示例 1： 输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2 示例 2： 输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] .
1.两数之和LeetCode(js)
m0_67430715的博客
03-22 457
leetcode1 两数之和 js JavaScript 暴力法 双重for循环 哈希表
leetcode - 必背基础题（JS版）
seaalan的博客
11-22 1190
一、leetcode - 字符串 (JS) 二、leetcode - 二进制、数学类 (JS) 三、leetcode - 数组（JS） 四、leetcode - 二分查找（JS） 五、leetcode - 快慢指针（JS） 六、leetcode - 滑动窗口（JS） 七、leetcode - 矩阵（JS） 八、leetcode - 栈和队列（JS） 九、leetcode - 链表（JS） 十、leetcode - 二叉树（JS） 十一、leetcode - 并查集（JS） 十二、leetcode - 回溯（
JS实现 LeetCode 数组类算法（一）
忙着开花儿
07-16 322
更多算法实现见：https://github.com/Erindcl/Daily-algorithm   1. 两数之和 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。 你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。 思路：遍历数组，将数组的某个元素与在该元素后面的其他元素进行求和，将和与目标值进行比较，若相等则返回两元素的索引。代码如下： var two...
js刷LeetCode的坑
tutou_girl的博客
03-22 347
发现一个问题，想要[[1],[2]]这样的嵌套数组，当我把一个数组push到外层数组时，后面内层数组变化会影响最终这个嵌套数组！ 虽然已经把temp push到了res里，但是后面temp出栈，temp里的数组也出栈了。 push的时候新建一个数组就可以了 ...
LeetCode(JavaScript实现)——两数之和
Andy·Wu的专栏
08-08 508
这里写自定义目录标题题目JavaScript实现方法一：暴力解法方法二：使用Map方法 题目 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 来源：力扣（LeetCode） 链接：https
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三月的一天

你的鼓励将是我前进的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值