算法|最大堆、最小堆和堆排序的实现（JavaScript）

已于 2024-04-18 02:02:24 修改
阅读量459 收藏 8
点赞数 4
分类专栏： 算法 文章标签： 堆 排序算法 javascript
于 2024-04-18 02:02:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46219145/article/details/137896531
版权

一些概念

  • 堆：特殊的完全二叉树，具有特定性质的完全二叉树。
  • 大根堆：父节点 > 子节点
  • 小根堆：父节点 < 子节点

二叉堆也属于完全二叉树，所以可以用数组表示。

  • 若下标从1开始，左节点为 2*i ，右节点为 2*i+1 ，父节点为 i//2 。
  • 若下标从1开始，左节点为 2*i+1 ，右节点为 2*i+1+2 ，父节点为 (i-1)//2 。
    image.png

最大堆

两个重要方法，插入元素和移出元素。

  • 插入元素：在堆尾插入元素，调用辅助方法，将该元素上浮到正确位置。
  • 移出元素：将堆尾元素删去并替换到堆首，将该元素下沉到正确位置。

解释：

  • 上浮：如果父节点更大，则替换，循环直至比父节点小。
  • 下沉：如果子节点中较大的那个更小，则替换，循环直至子节点都比自身小。

实现

class MaxHeap {
	constructor() {
		this.heap = []
	}
	isEmpty() {
		return this.heap.length === 0
	}
	size() {
		return this.heap.length
	}
	#getParentIndex(idx) {
		return Math.floor((idx-1)/2)
	}
	#getLeft(idx) {
		return idx * 2 + 1
	}
	#getRight(idx) {
		return idx * 2 + 2
	}
	// 插入
	insert(v) {
		this.heap.push(v)
		this.#swim(this.size()-1)
	}
	// 删除最大值
	deleteMax() {
		const max = this.heap[0]
		this.#swap(0, this.size() - 1) // 将根和最后一个元素交换
		this.heap.pop() // 防止对象游离
		this.#sink(0) // 下沉，恢复有序性
		return max
	}
	// 第i个是否小于第j个
	#compare(a, b) {
			return a < b
	}
	// 交换
	#swap(i, j) {
		[this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]]
	}
	// 上浮
	#swim(k) {
		let parent = this.#getParentIndex(k)
		while(k > 0 && this.#compare(this.heap[parent], this.heap[k])) {
			this.#swap(parent, k)
			k = parent
			parent = this.#getParentIndex(k)
		}
	}
	// 下沉
	#sink(k) {
		while (this.#getLeft(k) < this.size()) {
			let j = this.#getLeft(k)
			// j 指向子节点的较大值
			if (j+1 < this.size() && this.#compare(this.heap[j], this.heap[j+1])) j++
			// 如果子节点都小
			if (this.#compare(this.heap[j], this.heap[k])) break
			this.#swap(k, j)
			k = j
		}
	}
}

测试

const mh = new MaxHeap()
mh.insert(20)
mh.insert(80)
mh.insert(50)
mh.insert(40)
mh.insert(30)
mh.insert(40)
mh.insert(20)
mh.insert(10)
mh.insert(35)
mh.insert(15)
mh.insert(90)
console.log(mh.heap)
// [ <1 empty item>, 90, 80, 50, 35, 40, 40, 20, 10, 20, 15, 30 ]
mh.deleteMax()
mh.deleteMax()
mh.deleteMax()
console.log(mh.heap)
// [ <1 empty item>, 40, 35, 40, 20, 30, 15, 20, 10 ]

最小堆

与最小堆相比，仅是交换条件不同

实现

class MinHeap {
	constructor() {
		this.heap = []
	}
	isEmpty() {
		return this.heap.length === 0
	}
	size() {
		return this.heap.length
	}
	#getParentIndex(idx) {
		return Math.floor((idx-1)/2)
	}
	#getLeft(idx) {
		return idx * 2 + 1
	}
	#getRight(idx) {
		return idx * 2 + 2
	}
	// 插入
	insert(v) {
		this.heap.push(v)
		this.#swim(this.size()-1)
	}
	// 删除最大值
	deleteMin() {
		const max = this.heap[0]
		this.#swap(0, this.size() - 1) // 将根和最后一个元素交换
		this.heap.pop() // 防止对象游离
		this.#sink(0) // 下沉，恢复有序性
		return max
	}
	// 第i个是否小于第j个
	#compare(a, b) {
			return a > b
	}
	// 交换
	#swap(i, j) {
		[this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]]
	}
	// 上浮
	#swim(k) {
		let parent = this.#getParentIndex(k)
		while(k > 0 && this.#compare(this.heap[parent], this.heap[k])) {
			this.#swap(parent, k)
			k = parent
			parent = this.#getParentIndex(k)
		}
	}
	// 下沉
	#sink(k) {
		while (this.#getLeft(k) < this.size()) {
			let j = this.#getLeft(k)
			// j 指向子节点的较小值
			if (j+1 < this.size() && this.#compare(this.heap[j], this.heap[j+1])) j++
			// 如果子节点都大
			if (this.#compare(this.heap[j], this.heap[k])) break
			this.#swap(k, j)
			k = j
		}
	}
}

测试

const mh = new MinHeap()
mh.insert(20)
mh.insert(80)
mh.insert(50)
mh.insert(40)
mh.insert(30)
mh.insert(40)
mh.insert(20)
mh.insert(10)
mh.insert(35)
mh.insert(15)
mh.insert(90)
console.log(mh.heap)
// [10, 15, 20, 30, 20, 50, 40, 80, 35, 40, 90]
mh.deleteMin()
mh.deleteMin()
mh.deleteMin()
console.log(mh.heap)
// [20, 30, 40, 35, 40, 50, 90, 80]

堆（自定义比较函数）

默认为最大堆，根据元素的大小进行排序，可自定义排序规则，返回值为布尔值。

class Heap {
	constructor(compareFn) {
		this.heap = []
		this.compare = (typeof compareFn === 'function') ? compareFn : this.#defaultCompare
	}
	isEmpty() {
		return this.heap.length === 0
	}
	size() {
		return this.heap.length
	}
	#getParentIndex(idx) {
		return Math.floor((idx-1)/2)
	}
	#getLeft(idx) {
		return idx * 2 + 1
	}
	#getRight(idx) {
		return idx * 2 + 2
	}
	// 插入
	insert(v) {
		this.heap.push(v)
		this.#swim(this.size()-1)
	}
	// 删除最大值
	delete() {
		const max = this.heap[0]
		this.#swap(0, this.size() - 1) // 将根和最后一个元素交换
		this.heap.pop() // 防止对象游离
		this.#sink(0) // 下沉，恢复有序性
		return max
	}
	// 第i个是否小于第j个
	#defaultCompare(a, b) {
			return a < b
	}
	// 交换
	#swap(i, j) {
		[this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]]
	}
	// 上浮
	#swim(k) {
		let parent = this.#getParentIndex(k)
		while(k > 0 && this.compare(this.heap[parent], this.heap[k])) {
			this.#swap(parent, k)
			k = parent
			parent = this.#getParentIndex(k)
		}
	}
	// 下沉
	#sink(k) {
		while (this.#getLeft(k) < this.size()) {
			let j = this.#getLeft(k)
			// j 指向子节点的较大值
			if (j+1 < this.size() && this.compare(this.heap[j], this.heap[j+1])) j++
			// 如果子节点都小
			if (this.compare(this.heap[j], this.heap[k])) break
			this.#swap(k, j)
			k = j
		}
	}
}

测试

const mh = new Heap((a,b)=>a.val<b.val)
mh.insert({val: 20})
mh.insert({val: 45})
mh.insert({val: 56})
mh.insert({val: 12})
mh.insert({val: 93})
mh.insert({val: 34})
mh.insert({val: 12})
mh.insert({val: 84})
console.log(mh.heap)
// [
//   { val: 93 },
//   { val: 84 },
//   { val: 45 },
//   { val: 56 },
//   { val: 20 },
//   { val: 34 },
//   { val: 12 },
//   { val: 12 }
// ]
mh.delete()
mh.delete()
console.log(mh.heap)
// [
//   { val: 56 },
//   { val: 20 },
//   { val: 45 },
//   { val: 12 },
//   { val: 12 },
//   { val: 34 }
// ]

堆排序

（1）先原地创建一个最大堆，因为叶子节点没有子节点，因此只需要对非叶子节点从右向左进行下沉操作

（2）把堆首（堆的最大值）和堆尾替换位置，堆大小减一，保持非堆是递增的，保持数组最后一个元素是最大的，最后对堆首进行下沉操作（或者说把非堆重新堆化）。

（3）重复第二步直至清空堆。

注意：排序的数组第一个元素下标是 0 ，跟上面处理边界不一样。

实现

function heapSort (arr) {
	// arr = arr.slice(0) // 是否原地排序
	let N = arr.length - 1
	if (!arr instanceof Array) {
		return null
	}else if (arr instanceof Array && (N === 0 || N === -1) ) {
		return arr
	}
	function exch(i, j) {
		[arr[i], arr[j]] = [arr[j], arr[i]]
	}
	function less(i, j) {
		return arr[i] < arr[j]
	}
	function sink(k) {
		while (2 *k + 1 <= N) {
			let j = 2 * k + 1
			// j 指向子节点的较大值
			if (j+1 <= N && less(j, j+1)) {
				j++
			}
			// 如果子节点都小
			if (less(j, k)) break
			exch(k, j)
			k = j
		}
	}
	// 构建堆
	for(let i = Math.floor(N/2); i >= 0; i--) {
		sink(i)
	}
	// 堆有序
	while (N > 0) {
		exch(0, N--)
		sink(0)
	}
}

另一个实现

function heapSort (arr) {
	// arr = arr.slice(0) // 是否原地排序
	let N = arr.length
	if (!arr instanceof Array) {
		return null
	}else if (arr instanceof Array && (N === 0 || N === -1) ) {
		return arr
	}
	function getParentIndex(idx) {
		return Math.floor((idx-1)/2)
	}
	function getLeft(idx) {
		return idx * 2 + 1
	}
	function getRight(idx) {
		return idx * 2 + 2
	}
	function swap(i, j) {
		[arr[i], arr[j]] = [arr[j], arr[i]]
	}
	function compare(i, j) {
		return i < j
	}
	function sink(k) {
		while (getLeft(k) < N) {
			let j = getLeft(k)
			// j 指向子节点的较大值
			if (j+1 < N && compare(arr[j], arr[j+1])) j++
			// 如果子节点都小
			if (compare(arr[j], arr[k])) break
			swap(k, j)
			k = j
		}
	}
	// 构建堆
	for(let i = Math.floor(N/2); i >= 0; i--) {
		sink(i)
	}
	// 堆有序
	while (N > 1) {
		swap(0, --N)
		sink(0)
	}
}

测试

const arr1 = [15, 20, 30, 35, 20, 50, 40, 80, 10, 40, 90]
heapSort(arr1)
console.log(arr1)
// [10, 15, 20, 20, 30, 35, 40, 40, 50, 80, 90]
const arr2 = [62, 88, 58, 47, 35, 73, 51, 99, 37, 93];
heapSort(arr2)
console.log(arr2)
// [35, 37, 47, 51, 58, 62, 73, 88, 93, 99]

参考

  1. algs4
  2. 【JS手写最小堆（小顶堆）、最大堆（大顶堆）】：https://juejin.cn/post/7128369000001568798
  3. 【数据结构与算法(4)——优先队列和堆】：https://zhuanlan.zhihu.com/p/39615266
  4. 【最大堆最小堆及堆排序】：https://mingshan.fun/2019/05/14/heap/
  5. 【搞定JavaScript算法系列–堆排序】：https://juejin.cn/post/6844903830258188296
xChive
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JS数据结构之堆
qq_44222205的博客
07-30 726
堆一、堆的简介二、堆的实现1、结点数据结构2、插入元素3、删除元素4、判断堆是否为空5、创建堆6、堆排序 一、堆的简介 堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。 堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： 堆中某个节点的值总是不大于或不小于其父节点的值； 堆总是一棵完全二叉树。 大顶堆：每个节点的值都大于或者等于它的左右子节点的值。 小顶堆：每个节点的值都小于或者等于它的左右子节点的值。 堆的定义如下： n个元素的序列{k1,k2,ki,…,kn}当且
什么是堆？如何区分大堆和小堆？什么是向上调整和向下调整算法？如何实现堆排序？一篇文章带你秒杀考研数据结构堆。
fanzhaokai0420的博客
07-28 2827
考研数据结构总结，例题全解，向上调整算法，向下调整算法，堆排序的原理，大堆和小堆
JavaScript实现堆结构
Twinkle_sone的博客
03-16 629
堆的数据结构是完全二叉树或一堆数组，因为堆在逻辑上是一棵完全二叉树，在物理结构上是一个一维数组。堆将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。堆是非线性数据结构，相当于一维数组,有两个直接后继。堆就是用数组实现的二叉树，所以它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。
【数据结构】自己动手使用JavaScript实现二叉搜索树、二叉堆（第三篇）
weixin_45620943的博客
12-01 75
以上，如有不合理之处，还请帮忙指出，大家一起交流学习~
【数据结构】堆 -- 大堆小堆
m0_64645696的博客
02-01 2967
堆的物理结构其实是数组，逻辑结构则是二叉树。 堆的调整算法有多种，其中典型的是：大堆 和 小堆。 小堆的意思就是：父亲位，比孩子位，要小； 大堆：父亲位，比孩子位，要大。 下面我们来用图说明： 给一组数组：int a[] = { 27,15,19,18,28,34,65,49,25,37 }; 按照小堆的方式来排序： 由于我们父亲的两个孩子位都是小堆排序，所以我们可以直接从头开始进行一次排序即可。 #include <stdio.h> void Swap(int* pa,
【数据结构】堆的概念 | 从零开始实现数组堆
有道无术, 术尚可求。有术无道, 止于术。
11-27 2418
我们之前似乎确凿在C语言教学里讲过堆，但是那是操作系统中的堆，我们今天将要讲的堆是数据结构里的堆。数据结构中也有栈和堆，它跟操作系统对内存划分中的栈和堆没有关系。我横竖卷不动其他人，于是就打算再更亿篇博客罢。
JavaScript实现的选择排序算法实例分析
01-21
本文实例讲述了JavaScript实现的选择排序算法。分享给大家供大家参考，具体如下： 简单选择排序是人们最熟悉的比较方式，其算法思想为：从数组的开头开始，将第一个元素和其他元素进行比较。检查完所有元素后，最小...
heap:Java中的MinMax堆和堆排序实现
05-03
最小/最大堆数据结构和堆排序算法的完整javascript实现。 最小堆 最大堆 目录 。叶子（） 。尺寸（） 。克隆（） 。已验证（） 。使固定（） 。种类（） 。清除（） Heap.heapify（清单） Heap....
使用堆实现Top K算法（JS实现）
10-23
在JavaScript中实现Top K算法，可以结合数组和对象（模拟哈希表）来统计查询字符串的出现次数，然后使用最小堆数据结构来找到出现次数最多的K个字符串。这样，我们可以在有限的内存条件下高效地解决问题。 总结，...
javascript基本常用排序算法解析
10-19
对于大规模或性能要求高的排序任务，通常会使用更高效的排序算法，如归并排序、快速排序、堆排序等。 总结：了解并掌握这些基本排序算法，有助于理解排序的原理，同时在实际开发中根据需求选择合适的排序方法。在...
最大（小）堆Java实现
05-24
代码只是实现了最大堆的顺序存储，插入，删除，筛选建立
数据结构：堆和二叉树遍历
最新发布
2301_79490289的博客
03-20 663
堆顶就是这个堆最小的数，堆顶和这个堆的最后一个数换位置，然后再把最后一个数取出，再pop这个数。答：先取出50个建小堆，剩下的数和堆顶相比，遇到大于堆顶的数就直接替换掉堆顶的数。替换一次，小堆也要向下调整一次，保持它是一个小堆。向下调整就是每次取个数，由于和堆的最后一个数交换了位置，取出之后的二叉树需要调整一下才能成为一个堆。如果是大堆，就比较堆顶的和左右子树，大于它，堆顶和大的那个交换，这样层层交换下去。此问题也可以用于：内存空间不够，建堆数量有限，如何在大量的数据中取出前k个最大（小）的数。
堆排序（大堆）
热门推荐
不知道起啥名称的博客
05-08 1万+
前言：堆排序可分为大堆和小堆。      其实堆的空间结构实际上就是一棵完全二叉树，不过堆有它自己的限定条件。大堆就是树中每个父亲节点都要比孩子节点大，并且两个兄弟之间是没有大小区分的。小堆与之相反，就是每个父亲节点都要比孩子节点小。    堆的空间结构虽然是个完全二叉树，但是这样的结构也是我们为了好理解才想出来的，实际上堆是通过数组的下标进行相应的排序，因为完全二叉树中的结点的编号可以算出来，这...
最大堆和最小堆
kevin的博客
08-20 3284
堆的特性 必须是完全二叉树 用数组实现 任一结点的值是其子树所有结点的最大值或最小值 最大值时，称为“最大堆”，也称大顶堆； 最小值时，称为“最小堆”，也称小顶堆。 最大堆: 最小堆： 对于堆（Heap）这种数据结构，从根节点到任意结点路径上所有的结点都是有序的 堆的实现 在堆中，一般将数组第一个元素赋值为null，不用数组第一位，所以 根节点：n 左子树则为...
堆的JavaScript实现
一车面包人的博客
09-07 1076
由于JavaScript缺少内置的优先队列实现（例如Java的PriorityQueue，Python的heapq），导致刷题时碰到优先队列相关的题只能换语言写，还是自己写一个吧。 完整实现代码见 github 二叉堆可视化 概念 堆 作为前置知识，首先要了解一下堆的基本概念。 堆首先是一棵完全二叉树，也就是每层从左边依次填充的二叉树，由于这个特性，使它可以方便的由数组实现。 取一个数组arr，下标为0位置废弃不用，从1开始。那么对任意的下标i来说，它的父节点和左右子节点分别为 父节点：arr[i/2]
javascript实现堆排序
qq_33745501的博客
03-13 588
堆排序堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图： function heapSort(arr) { for(var i=Math.floor(arr.length/2)-1;i&gt;=0;i--){ //从上而下生成大顶堆 heapA...
数据结构Javascript实现 | 堆 heap
栈斗民族的博客
04-28 525
概念 堆可以被看做一棵完全二叉树的数组对象。 图示 代码 最小堆 - 根节点为最小值的堆 class MinHeap { constructor() { // index为0时赋值null,便于计算子节点index和父节点index的关系 this.heap = [null] } insert(node) { this.heap.push(node); ...
数据结构-JavaScript实现堆
Ybbb的博客
04-21 677
什么是堆？ 这里的堆和内存的堆是不一样的，这里的堆是一种储存方式。 堆其实是一种优先队列，也就是说队列中存在优先级，比如队列中有很多待执行任务，执行时会根据优先级找优先度最高的先执行。 堆的实现 一般使用完全二叉树实现堆。 最大堆：一棵完全二叉树中儿子节点永远小于父亲节点。 最小堆：一棵完全二叉树中儿子节点永远小于父亲节点。 另外从根节点，到任意节点路径上都是有序的。如下图 左边蓝色为最大堆，右...
快速排序等经典排序算法C++、Java、python等版本
09-29
本资源提供了快速排序以及其它经典排序算法如冒泡排序、插入排序、选择排序、希尔排序、计数排序、基数排序、桶排序、归并排序和堆排序的实现，涵盖C++、Java和Python三种编程语言。排序算法是计算机科学中的重要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值