JavaScript中的[堆heap]数据结构

最新推荐文章于 2024-09-27 22:08:24 发布
最新推荐文章于 2024-09-27 22:08:24 发布
阅读量930 收藏 2
点赞数
分类专栏： 数据结构 JS 算法 文章标签： javascript 数据结构 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjh1840226173/article/details/122274115
版权
JS 同时被 3 个专栏收录
9 篇文章 0 订阅
订阅专栏
数据结构
2 篇文章 0 订阅
订阅专栏
算法
2 篇文章 0 订阅
订阅专栏
本文详细介绍了JavaScript中如何使用数组构建最小堆数据结构，包括节点位置计算、插入、删除堆顶等操作。此外，还展示了如何在LeetCode算法题中应用堆解决第k个最大元素、前K个高频元素和合并K个排序链表的问题。通过实例代码加深了对堆数据结构的理解。
摘要由CSDN通过智能技术生成

JavaScript中的[堆heap]数据结构

前言

javaScript 中数据结构都是由数组对象构建出来的，堆由数组构建【】，本质是完全二叉树结构

JS中的堆：
  找到节点位置的，写插入删除查找替换等方法

一、节点位置和堆的用处

1、节点位置

  • 左侧子节点的位置 : 2 * index + 1
  • 右侧子节点的位置 : 2 * index + 2
  • 父节点的位置 : (index -1) / 2 。 可以用位运算表示 (i - 1) >> 1

2、堆的运用

  • 快速找最大最小值，时间复杂度O(1)
  • 找第k个最大元素
    最大最小元素

二、最小堆类和方法

1.构建最小堆类

插入涉及移动父节点元素，getParentIndex(i) 方法获取父节点，upShift(index) 方法来移动当前节点， swap(i1,i2)方法来交换位置的值。


// 构建最小堆类
class MinHeap {
  constructor() {
    this.heap = []
  }
  // 交换
  swap(i1, i2) {
    let temp = this.heap[i1]
    this.heap[i1] = this.heap[i2]
    this.heap[i2] = temp
  }
  // 获取父节点位置
  getParentIndex(i) {
    return (i - 1) >> 1
  }
   // 获取左子节点位置
   getLeftIndex(i) {
    return 2 * i + 1
  }
   // 获取右子节点位置
   getRightIndex(i) {
    return 2 * i + 2
  }
  // 上移
  upShift(index) {
    if(index == 0) return
    const parentIndex = this.getParentIndex(index)
    if(this.heap[parentIndex] > this.heap[index]) {
      this.swap(index, parentIndex)
      this.upShift(parentIndex)
    }
  }
  // 下移
  downShift(index) {
    const leftIndex = this.getLeftIndex(index)
    const rightIndex = this.getRightIndex(index)
    if(this.heap[leftIndex] < this.heap[index]) {
      this.swap(leftIndex, index)
      this.downShift(leftIndex)
    }
    if(this.heap[rightIndex] < this.heap[index]) {
      this.swap(rightIndex, index)
      this.downShift(rightIndex)
    }
  }
  // 插入
  insert(value) {
    this.heap.push(value)
    this.upShift(this.heap.length - 1)
  }
  // 删除堆顶
  pop() {
    this.heap[0] = this.heap.pop()
    this.downShift(0)
  }
}

2. 插入方法

根据最小堆的结构进行插入
时间复杂度为O（logk),

 // 插入
  insert(value) {
    this.heap.push(value)
    this.upShift(this.heap.length - 1)
  }

测试插入方法


let minheap = new MinHeap()

minheap.insert(6)
minheap.insert(2)
minheap.insert(3)
minheap.insert(1)


console.log(minheap.heap);

结果
在这里插入图片描述

3. 删除堆顶

  • 用数组尾部元素替换堆顶（直接删除堆顶会破环堆结构）
  • 下移： 将新堆顶和它的子节点进行交换，直到子节点大于大于这新的堆顶
  • 大小为k 的堆顶中删除堆顶的时间复杂度为O（logk),和插入一样

使用获取左右节点的方法 getLeftIndex(i) ，getRightIndex(i)和下移方法 downShift(index)，交换方法swap(i1,i2)

 // 删除堆顶
 /** this.heap[0] 堆顶值
 *  this.heap.pop() 数组尾部元素的值
 */
  pop() {
    this.heap[0] = this.heap.pop()
    this.downShift(0)
  }
  • 验证一下

let minheap = new MinHeap()

minheap.insert(6)
minheap.insert(2)
minheap.insert(3)
minheap.insert(1)
minheap.pop()

console.log(minheap.heap);

结果：
在这里插入图片描述

4. 获取堆顶和堆的大小vscode 调试

这两个比较简单，直接返回数组第一个元素和长度

 // 获取堆顶
  peek() {
    return this.heap[0]
  }
  // 获取堆大小
  size() {
    return this.heap.length
  }
  • 可以在vs code 中使用node.js 的调试环境进行查看变量方法等，这里可以监听peek() 和size()
  • F5启动调试
    在这里插入图片描述
  • 在调用堆栈栏目进行单步调试在这里插入图片描述
  • 在监视栏目设置断点监听
    在这里插入图片描述

三. LeetCode 算法题中的堆

以下的算法题，在我们上面的堆类的基础上进行实现

1、215 数组中第k个最大元素

在这里插入图片描述
解题步骤
在这里插入图片描述


let findKLargest = function (nums, k) {
  // 创建堆实例
  const heap = new MinHeap()
  for(let num of nums) {
    // 将数组的值依次插入到堆里
    heap.insert(num)
    // 判断堆的容量是否超过k 
    if (heap.size() > k) {
      // 如果超过，就删除堆顶
      heap.pop()
    }
  }
  // 返回堆顶
  return heap.peek()
}

let arr1 = [3,2,1,5,6,4]
let arr2 = [3,2,2,1,2,4,5,5,6]

console.log(findKLargest(arr1, 2)); // 5

console.log(findKLargest(arr2, 4)); // 4
  • 时间复杂度：O（n*logK)
  • 空间复杂度： O（logK)

2、347.前K个高频元素

在这里插入图片描述

非堆结构的算法实现
k <= n


let topKFrequent = function (nums, k) {
  const map = new Map();
  for(let n of nums) {
    map.set(n, map.has(n) ? map.get(n) + 1 : 1)
  }
 
  const list = Array.from(map).sort((a, b) => b[1] - a[1])
  console.log(list.slice(0, k));
  return list.slice(0, k).map(n => n[0])
}
let arr3 = [1,1,1,2,2,3]
console.log(topKFrequent(arr3, 2));// [1, 2]
console.log(topKFrequent([1], 1)); // [1]
  • 时间复杂度：O（n*log n)
  • 空间复杂度： O（log n)

堆结构的实现
……
下面的最小堆类符合传入对象时，对对象的value的比较的情况，
因此只在上移、下移的方法中的 if 判断时进行修改，
分别是判断父、左、右 节点是否存在，
因为要取里面的value，防止undefined的时候报错，
其余没有修改，为方便阅读就都啪的贴上了

 if(this.heap[parentIndex] && this.heap[parentIndex].value > this.heap[index].value) 
 
 if(this.heap[leftIndex] && this.heap[leftIndex].value < this.heap[index].value)
 
 if(this.heap[rightIndex] && this.heap[rightIndex].value < this.heap[index].value)

堆类和题目的算法和输出结果如下：


class MinHeap {
  constructor() {
    this.heap = []
  }
  // 交换
  swap(i1, i2) {
    let temp = this.heap[i1]
    this.heap[i1] = this.heap[i2]
    this.heap[i2] = temp
  }
  // 获取父节点位置
  getParentIndex(i) {
    return (i - 1) >> 1
  }
   // 获取左子节点位置
   getLeftIndex(i) {
    return 2 * i + 1
  }
   // 获取右子节点位置
   getRightIndex(i) {
    return 2 * i + 2
  }
  // 上移
  upShift(index) {
    if(index == 0) return
    const parentIndex = this.getParentIndex(index)
    if(this.heap[parentIndex]&& this.heap[parentIndex].value > this.heap[index].value) {
      this.swap(index, parentIndex)
      this.upShift(parentIndex)
    }
  }
  // 下移
  downShift(index) {
    const leftIndex = this.getLeftIndex(index)
    const rightIndex = this.getRightIndex(index)
    if(this.heap[leftIndex] && this.heap[leftIndex].value < this.heap[index].value) {
      this.swap(leftIndex, index)
      this.downShift(leftIndex)
    }
    if(this.heap[rightIndex] && this.heap[rightIndex].value < this.heap[index].value) {
      this.swap(rightIndex, index)
      this.downShift(rightIndex)
    }
  }
  // 插入
  insert(value) {
    this.heap.push(value)
    this.upShift(this.heap.length - 1)
  }
  // 删除堆顶
  pop() {
    this.heap[0] = this.heap.pop()
    this.downShift(0)
  }
  // 获取堆顶
  peek() {
    return this.heap[0]
  }
  // 获取堆大小
  size() {
    return this.heap.length
  }
}

let topKFrequent = function (nums, k) {
  const map = new Map();
  for(let n of nums) {
    map.set(n, map.has(n) ? map.get(n) + 1 : 1)
  }
  const heap = new MinHeap()
  map.forEach((value, key) => {
    heap.insert({value, key})
    if(heap.size() > k) {
      heap.pop()
    }
  })
  return heap.heap.map(a => a.key)
}
let arr3 = [1,1,1,2,2,3]
console.log(topKFrequent(arr3, 2));// [2, 1]
console.log(topKFrequent([1], 1)); // [1]

注意： 这里题目对输出的顺序没有要求，和非堆结构相比发现了吗【1，2】 【2，1】

  • 时间复杂度：O（n*logK)
  • 空间复杂度： O（logK)

3、23.合并K个排序链表

在这里插入图片描述
解题思路

  • 新链表的下一个节点一定是K个链表头重的最小节点

解题步骤
在这里插入图片描述


// 构建最小堆类
class MinHeap {
  constructor() {
    this.heap = []
  }
  // 交换
  swap(i1, i2) {
    let temp = this.heap[i1]
    this.heap[i1] = this.heap[i2]
    this.heap[i2] = temp
  }
  // 获取父节点位置
  getParentIndex(i) {
    return (i - 1) >> 1
  }
   // 获取左子节点位置
   getLeftIndex(i) {
    return 2 * i + 1
  }
   // 获取右子节点位置
   getRightIndex(i) {
    return 2 * i + 2
  }
  // 上移
  upShift(index) {
    if(index == 0) return
    const parentIndex = this.getParentIndex(index)
    if(this.heap[parentIndex]&& this.heap[parentIndex].value > this.heap[index].value) {
      this.swap(index, parentIndex)
      this.upShift(parentIndex)
    }
  }
  // 下移
  downShift(index) {
    const leftIndex = this.getLeftIndex(index)
    const rightIndex = this.getRightIndex(index)
    if(this.heap[leftIndex] && this.heap[leftIndex].value < this.heap[index].value) {
      this.swap(leftIndex, index)
      this.downShift(leftIndex)
    }
    if(this.heap[rightIndex] && this.heap[rightIndex].value < this.heap[index].value) {
      this.swap(rightIndex, index)
      this.downShift(rightIndex)
    }
  }
  // 插入
  insert(value) {
    this.heap.push(value)
    this.upShift(this.heap.length - 1)
  }
  // 删除堆顶
  pop() {
    if(this.size() === 1) return this.heap.shift()
    const top = this.heap[0]
    this.heap[0] = this.heap.pop()
    this.downShift(0)
    return top
  }
  // 获取堆顶
  peek() {
    return this.heap[0]
  }
  // 获取堆大小
  size() {
    return this.heap.length
  }
}


function ListNode(value) {
  this.value = value
  this.next = null
}

let mergeKlists = function (lists) {
  const res = new ListNode(0)
  let p = res
  const heap = new MinHeap()
  lists.forEach(list => {
    if (list) {
      heap.insert(list)
    }
  })
  while (heap.size()){
    const n = heap.pop()
    p.next = n
    p = p.next
    if (n.next) {
      heap.insert(n.next)
    }
  }
  return res.next
}

let lists = [[1, 4, 5], [1, 3, 4], [2, 6]]
console.log(mergeKlists(lists));

这道题有点难啊

  • 时间复杂度：O（n*logK)
  • 空间复杂度： O（K)

6.文章结构框架md

@[TOC](<center>Title</center>)
<hr style=" border:solid; width:100px; height:1px;" color=#000000 size=1">

# 前言

<font color=#999AAA >**简述文章内容或者创作目的**</font>

<font face = '宋体' color = black size = 5>**完成目标：**
&emsp;&emsp;文章想要达到什么样的目标

<hr style=" border:solid; width:100px; height:1px;" color=#000000 size=1">

# 一、
<font face = '宋体' color = black size = 5>

# 二、
## 1.

## 2.

## 3.

## 4.

## 5.

## 6.

# 最后
><font face="宋体"  color = black size = 4>最后想和读者说的话

最后

堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。

堆在实际的应用中还是右出现的，调用堆栈这些，堆本质上是完全二叉树，堆在js中用数组表示【】，
万字文还真有点多。

在这里插入图片描述

释义

堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：
堆中某个结点的值总是不大于或不小于其父结点的值；
堆总是一棵完全二叉树。
将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
堆是非线性数据结构，相当于一维数组，有两个直接后继。
堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。
(且)或者(), ()
若将和此次序列对应的一维数组（即以一维数组作此序列的存储结构）看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有非终端结点的值均不大于（或不小于）其左、右孩子结点的值。由此，若序列{k1,k2,…,kn}是堆，则堆顶元素（或完全二叉树的根）必为序列中n个元素的最小值（或最大值）

算法思想

不必将值一个个地插入堆中，通过交换形成堆。假设一个小根堆的左、右子树都已是堆，并且根的元素名为root ，其左右子结点为 left和right ，这种情况下，有两种可能：
（1）root <= left 并且root <= right，此时堆已完成；
（2） root >= left或者root >= right ，此时root 应与两个子女中值较小的一个交换，结果得到一个堆，除非 root仍然大于其新子女的一个或全部的两个。这种情况下，我们只需简单地继续这种将root “拉下来”的过程，直至到达某一个层使它小于它的子女，或者它成了叶结点。

傍晚了要吃饭了

怕浪小乌龟
关注
专栏目录
JavaScript:实现Heap堆算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-13 256
JavaScript:实现Heap堆算法(附完整源码)
JavaScript实现heapsort堆排序算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-23 342
JavaScript实现heapsort堆排序算法（附完整源码）Heap.js完整源代码MinHeap.js完整源代码Comparator.js完整源代码Sort.js完整源代码HeapSort.js完整源代码 Heap.js完整源代码 import Comparator from 'Comparator'; export default class Heap { constructor(comparatorFunction) { if (new.target === Heap) {
JavaScript 数据结构——堆
火星基地
03-16 725
概念 堆是一种特殊的完全二叉树。 它的所有节点都大于等于或小于等于它的子节点。 最大堆：所有节点都大于等于它的子节点 最小堆：所有节点都小于等于它的子节点 实现 JavaScript中通常用数组表示堆，如下图堆，可用数组表示： 即按照广度优先遍历的顺序依次填入到数组中。 另外，节点位置与数组的下标index有如下关系： 任意节点的左侧子节点（若存在）的位置：2 × index + 1 任意节点的右侧子节点（若存在）的位置：2 × index + 2 任意节点的父节点的位置：( inde
监控网页JS堆内存
最新发布
weixin_44248903的博客
09-27 266
监控网页JS堆内存
JavaScript数据结构之 堆排序
liuyaqi1993的博客
04-07 1651
以前没学过这种排序，今天看了一下，最好、最坏时间复杂度都是nlog2n。 原理可以参考这篇博客，里面的图不错 http://blog.csdn.net/xiaoxiaoxuewen/article/details/7570621/ JavaScript实现： /** * 对数组中的前n项整理成堆 * @param array * @param n */ function re
js(JavaScript)数据结构之堆（Heap）
星辰迷上大海的博客
01-15 1389
JavaScript中的堆（Heap）是一块用于存储动态分配内存的区域。在这个堆里，我们可以存储复杂的数据结构，比如对象和数组。不同于栈（Stack），堆的大小不是固定的，而是可以根据需要动态扩展。
数据结构Javascript实现 | 堆 heap
栈斗民族的博客
04-28 571
概念 堆可以被看做一棵完全二叉树的数组对象。 图示 代码 最小堆 - 根节点为最小值的堆 class MinHeap { constructor() { // index为0时赋值null,便于计算子节点index和父节点index的关系 this.heap = [null] } insert(node) { this.heap.push(node); ...
js-fibonacci-heap：JavaScript的斐波那契堆数据结构
02-12
Fibonacci用于JavaScript的堆数据结构。 参见 。 父母是 。 :warning: 该代码要求定义regeneratorRuntime ，例如，通过导入 。 let heap = new FibonacciHeap ( compare . increasing ) ; 参考
JavaScript实现数据结构
01-02
9. 堆（Heap）：堆是一种特殊的树形数据结构，满足堆属性（最大堆或最小堆），常用于优先队列的实现。 10. 字符串（String）：虽然字符串在JavaScript中被视为不可变对象，但它也是一种特殊的数据结构，可以进行...
基于JavaScript讲解的数据结构和算法
05-21
5. **堆（Heap）**：堆是一种特殊的树形数据结构，满足最大堆或最小堆性质。JavaScript中可以通过数组模拟堆，用于实现优先队列等高效操作。 6. **哈希表（Hash Table）**：哈希表通过键值对实现快速查找，...
data-structures:研究 JavaScript 中的基本数据结构实现
06-03
8. **堆**（Heap）：堆是一种特殊的树形数据结构，通常用于优先队列。在JavaScript中，可以使用数组来实现最小堆或最大堆，通过调整元素的位置来保持堆的性质。 9. **二叉树**（Binary Tree）：二叉树每个节点最多...
jsheap:Javascript 中的二进制堆实现
06-10
jsheap Javascript 中的二进制堆实现 二叉堆是满足堆排序特性的完全二叉树。 排序可以是以下两种类型之一： min-heap属性：每个节点的值都大于或等于其父节点的值，最小值元素位于根节点。 max-heap属性：每个节点的值都小于或等于其父节点的值，最大值元素在根节点。 堆不是已排序的结构，可以将其视为部分有序的：在任何给定级别上的节点之间，甚至在兄弟节点之间，都没有特定的关系。 当您需要删除具有最高（或最低）优先级的对象时，它是有用的数据结构。 堆的一个常见用途是实现优先级队列。 安装 $ npm install --save jsheap 应用程序接口 堆树（参数） 初始化一个 HeapTree 对象 参数： params ：带有键'src'（源数组）和'check'（是否执行堆化）的对象 HeapTree.getArray() 获取底层数组结构 HeapT
JavaScript-Stack，Heap
一缕阳光@的博客
04-18 1359
最近做了些关于变量提升类型的题，由于之前做过相关的题，就信誓旦旦的输出了答案，结果出现了很多错误，于是去花了一部分时间研究了下相关的内容，这里重点了解下 js的Stack ，Heap。 这里写目录标题一、Stack ，Heap了解内存存储GO（global object）全局对象。EC:全局的执行环境(全局执行上下文)GO VS EC(G)栈内存 VS 堆内存栈内存的作用堆内存的作用「全局上下文」变量的访问和赋值「全局上下文」访问变量「全局上下文」赋值变量：a = 100练习题 一、Stack ，Heap
js的堆（heap）、栈（stack）
weixin_43758377的博客
08-31 1033
堆（heap）、栈（stack） 堆是堆内存的简称，栈是栈内存的简称。说到堆栈，我们讲的就是内存的使用和分配了，没有寄存器的事，也没有硬盘的事。 各种语言在处理堆栈的原理上都大同小异。堆是动态分配内存，内存大小不一，也不会自动释放。栈是自动分配相对固定大小的内存空间，并由系统自动释放。 js的基本类型就5种，Undefined、Null、不是new出来的布尔、数字和字符串，它们都是直接按值存储在栈中的，每种类型的数据占用的内存空间的大小是确定的，并由系统自动分配和自动释放。这样带来的好处就是，内存可以及时得
JavaScript heap out of memory
p的博客
05-06 3659
ionic 打包报 FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory 解决办法：在package.json里添加 "config": { "ionic_source_map_type": "cheap-source-map"...
js Heap 的简单使用
阿豪
04-17 332
原文链接: js Heap 的简单使用 上一篇: ...
实现Heap堆算法（JavaScript）
CsCufft的博客
09-27 65
堆（Heap）是一种基于树结构的数据结构，通常用于高效地实现优先队列。本文将介绍如何使用JavaScript实现Heap堆算法，并提供相应的源代码。
【算法】在JS中实现Heap堆及堆操作
欧阳天涵的专栏
03-28 517
Heap是一种满足堆属性的专用基于树的数据结构。在一个堆中，对于任何给定节点（除了根节点），该节点的值始终根据其父节点排序。**最大堆：**在最大堆中，对于除根节点外的每个节点，节点的值最多等于其父节点的值。这意味着最大的元素位于根节点，随着向下遍历树，元素变得更小。简单来说，所有子节点都必须小于其父节点。**最小堆：**在最小堆中，对于除根节点外的每个节点，节点的值至少等于其父节点的值。这意味着最小的元素位于根节点，随着向下遍历树，元素变得更大。
js中的栈(stack)和堆(heap)
qq_31594665的博客
12-06 586
程序运行时候，需要内存空间存放数据。系统划分出的两种内存空间就叫做stack（栈）和heap（堆）。由操作系统自动分配内存空间，自动释放，存储的是基础变量以及一些对象的引用变量，占据固定大小的空间。由操作系统动态分配的内存，大小不定也不会自动释放，一般由程序员分配释放，也可由垃圾回收机制回收（程序结束时由浏览器回收）。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值