js实现的大根堆算法(基于链式的m叉树)

最新推荐文章于 2024-11-24 00:04:08 发布
转载 最新推荐文章于 2024-11-24 00:04:08 发布 · 91 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://juejin.im/post/5c3e049f6fb9a049b22223fb
文章标签：

#json #数据结构与算法

本文介绍了一种基于m叉树的堆排序算法实现，包括数据生成、m叉树构建、堆调整、堆排序等核心步骤，并通过面向过程和面向对象两种方式对比展示了算法细节。此外，还提供了算法正确性和性能的验证方法。 

面向过程版本

var COUNT = 3;
/*
	获取待排序数据，数据的个数和值随机生成
*/
function getData() {
	var arr = [];
	var i = 0;
	var len = Math.max(10, ~~(Math.random() * 30 ));
	while(i <  len) {
		arr.push(~~(Math.random() * 100 ));
		i++;
	}	
	return arr;
}
/*
	节点构造函数
	@param val {any} 节点的值
	@param position {int} 节点的位置，即第几个节点
*/
function Node(val, position) {
	// 叉数，例如二叉树
	var count = COUNT;
	// 初始化节点的孩子为null
	while(count) {
		this[count--] = null;
	}
	this.position = position;
	// 父节点、前继节点、后继节点
	this.parent = null;
	this.pre = null;
	this.next = null;
	// 孩子个数
	this.childs = 0;
	this.val = val;
}
/*
	构造COUNT叉树
*/
function makeTree(arr) {
	var i = 1;
	var root = new Node(arr[0], 0);
	var position = 1;
	var count = COUNT;
	// 初始化队列
	var queue = [root];
	// 保存上一个遍历的节点，用于前后节点的连接
	var preNodePtr;
	// 构造m叉树完成后，从哪个节点开始遍历这棵树，从最后一个非叶子节点开始
	var neededNode;
	// 是否已经找到了最后一个非叶子节点
	var isFind = false;
	// 用于寻找最后的非叶子节点
	var preNode = root;
	// 利用队列进行广度遍历
	while(queue.length) {
		var node = queue.shift();
		i = 1;
		// 给当前节点配置孩子数据，个数为COUNT
		while(i <= count) {
			// 判断当前的节点数是否已经超过数据的长度
			if (position < arr.length) {
				var newNode = new Node(arr[position], position);
				node[i] = newNode;
				newNode.parent = node;
				newNode.pre = preNode;
				preNode.next = newNode;
				node.childs++;
				queue.push(newNode);
				preNode = newNode;
				i++;
				position++;
			} 
			// 全部数据赋值完成
			else {
				break;
			}
		}
		// 是否找到了最后的非叶子节点
		if (!isFind) {
			// 当前节点的孩子数为0，说明前一节点为最后一个非叶子节点
			if (node.childs === 0) {
				neededNode = preNodePtr;
				isFind = true;
				return {
					root: root,
					startNode: neededNode
				};
			} 
			// 当前节点的孩子数小于分支数COUNT，说明当前节点为最后的非叶子节点
			else if (node.childs < COUNT){
				neededNode = node;
				isFind = true;
				return {
					root: root,
					startNode: neededNode
				};
			}
			// 保存前一个节点
			else {
				preNodePtr = node;
			}
		}
	}
	return root;
}
// 找出一棵树的最后非叶子节点，已经在makeTree里实现
function findNode(root) {
	var queue = [root];
	var node;
	var count = COUNT;
	var i = 1;
	var preNodePtr;

	while(queue.length) {
		node = queue.shift();
		if (node.childs === 0) {
			return preNodePtr;
		} else if (node.childs < COUNT) {
			return node;
		}
		preNodePtr = node;
		while(i <= count) {
			queue.push(node[i++]);
		}
		count = COUNT;	
	}
}
// 根据一颗无序的m叉树构建m叉大堆树
function buildHeapTree(root, startNode) {
	var node = startNode;
	// 从最后一个非叶子节点开始，到根节点结束，遍历其中的所有节点，调整成m叉堆的形式，最后根节点为值最大的节点
	while(node) {
		adjustHeapTree(node);
		node = node.pre;
	}
	return root;
}
// 以node节点为根节点，endNode为结束节点。把node子树调整成m叉堆，
function adjustHeapTree(node, endNode) {
	var i = 1;
	var max = node.val;
	var position = 0;
	var isEnd = false;
	while(i <= COUNT) {
		// 是否已经到达了结束节点，是则结束所有步骤
		if (endNode && node[i] && node[i].position >= endNode.position) {
			isEnd = true;
			break;
		}
		// 找到node节点和孩子中的最大值。
		if (node[i] && node[i].val > max) {
			max = node[i].val;
			position = i;
		}
		i++;
	}
	var temp;
	// 如果node节点的值不是最大的，那么和值最大的孩子节点进行值的互换
	if (position !== 0) {
		temp = node.val;
		node.val = node[position].val;
		node[position].val = temp;
		/*
			是否已经到达结束节点，是的话不需要再进行调整后续的子树，因为孩子节点的position和父节点的大
			以被置换值的孩子节点为根节点，调整成m叉树	
		*/
		!isEnd && adjustHeapTree(node[position], endNode);
	}	
}

/*
	对排序的主流程
*/
function heapSort(root, startNode) {
	if (!root.childs) {
		return;
	}
	
	var node = startNode;
	// 获取整个树的最后一个节点，即最后一个非叶子节点的最后一个节点
	var lastChild = getNodeLastChild(node);
	var endNode = lastChild;
	var temp;
	// 首先构建m叉堆
	buildHeapTree(root, startNode);
	while(endNode !== root) {
		// 把m叉堆中值最大的节点，即根节点的值和最后一个孩子的值互换
		temp = root.val;
		root.val = endNode.val;
		endNode.val = temp;
		// 以根节点为起点，endNode为终点，调整子树为m叉堆
		adjustHeapTree(root, endNode);
		// 终点根节点方向，往前挪一位，此时，endNode后面的节点都是有序的
		endNode = endNode.pre;
	}
}
// 或许某个节点的最后一个孩子节点
function getNodeLastChild(node) {
	var count = COUNT;
	while(count) {
		if (node[count]) {
			return node[count];
		}
		count--;
	}
	return null;
}
// 广度遍历root为根节点的m叉树
function echo(root) {
	var queue =[root];
	var result = [];
	var i = 1;
	while(queue.length) {
		i = 1;
		var node = queue.shift();
		result.push(node.val);
		while(i <= node.childs) {
			queue.push(node[i++]);
		}
	}
	console.log('sort: data',JSON.stringify(result),'\n');
	return result;
}
// 断言堆排序算法产生的数据是升序的
function assert(result) {
	var i = 0;
	while(i < result.length - 2) {
		if (result[i] > result[i+1]) {
			console.log('error',i, result,'\n');
			break;
		}
		i++;
	}
}
function start() {
	var data = getData();
	console.log('source data:',JSON.stringify(data));
	var {root, startNode} = makeTree(data);
	heapSort(root, startNode);
	assert(echo(root));
}
start();



粗糙的面向对象版本

function HeapSort(count) {
	this.data = [];
	this.COUNT = count || 2;
}

HeapSort.prototype = {
	getData: function() {
		var arr = [];
		var i = 0;
		var len = Math.max(10, ~~(Math.random() * 30 ));
		while(i <  len) {
			arr.push(~~(Math.random() * 100 ));
			i++;
		}	
		this.data = arr;
		return arr;
	},
	makeTree: function makeTree() {
		var arr = this.data;
		var i = 1;
		var root = this.getNode(arr[0], 0);
		var position = 1;
		var count = this.COUNT;
		var queue = [root];
		var preNodePtr;
		var neededNode;
		var isFind = false;
		var preNode = root;
		while(queue.length) {
			var node = queue.shift();
			i = 1;
			while(i <= count) {
				if (position < arr.length) {
					var newNode = this.getNode(arr[position], position);
					node[i] = newNode;
					newNode.parent = node;
					newNode.pre = preNode;
					preNode.next = newNode;
					node.childs++;
					queue.push(newNode);
					preNode = newNode;
					i++;
					position++;
				} else {
					break;
				}
			}

			if (!isFind) {
				if (node.childs === 0) {
					neededNode = preNodePtr;
					isFind = true;
					this.startNode = neededNode;
					this.root = root;
				} else if (node.childs < this.COUNT){
					neededNode = node;
					isFind = true;
					this.startNode = neededNode;
					this.root = root;
				} else {
					preNodePtr = node;
				}
			}
		}
		return root;
	},
	findNode: function findNode(root) {
		var queue = [root];
		var node;
		var count = COUNT;
		var i = 1;
		var preNodePtr;

		while(queue.length) {
			node = queue.shift();
			if (node.childs === 0) {
				return preNodePtr;
			} else if (node.childs < this.COUNT) {
				return node;
			}
			preNodePtr = node;
			while(i <= count) {
				queue.push(node[i++]);
			}
			count = this.COUNT;	
		}
	},
	buildHeapTree: function buildHeapTree() {
		var node = this.startNode;
		while(node) {
			this.adjustHeapTree(node);
			node = node.pre;
		}
	},
	adjustHeapTree: function adjustHeapTree(node, endNode) {
		var i = 1;
		var max = node.val;
		var position = 0;
		var isEnd = false;
		while(i <= this.COUNT) {
			if (endNode && node[i] && node[i].position >= endNode.position) {
				isEnd = true;
				break;
			}
			if (node[i] && node[i].val > max) {
				max = node[i].val;
				position = i;
			}
			i++;
		}
		var temp;
		if (position !== 0) {
			temp = node.val;
			node.val = node[position].val;
			node[position].val = temp;
			!isEnd && this.adjustHeapTree(node[position], endNode);
		}	
	},
	heapSort: function heapSort() {
		if (!this.root.childs) {
			return;
		}
		var root = this.root;
		var node = this.startNode;
		var lastChild = this.getNodeLastChild(node);
		var endNode = lastChild;
		var temp;
		this.buildHeapTree();
		while(endNode !== root) {
			temp = root.val;
			root.val = endNode.val;
			endNode.val = temp;
			this.adjustHeapTree(root, endNode);
			endNode = endNode.pre;
		}
	},
	getNodeLastChild: function getNodeLastChild(node) {
		var count = this.COUNT;
		while(count) {
			if (node[count]) {
				return node[count];
			}
			count--;
		}
		return null;
	},
	echo: function echo() {
		var queue =[this.root];
		var result = [];
		var i = 1;
		while(queue.length) {
			i = 1;
			var node = queue.shift();
			result.push(node.val);
			while(i <= node.childs) {
				queue.push(node[i++]);
			}
		}
		this.result = result;
		console.log('sort: data',JSON.stringify(result),'\n');
	},
	assert: function assert() {
		var result = this.result;
		var i = 0;
		while(i < result.length - 2) {
			if (result[i] > result[i+1]) {
				console.log('error',i, result,'\n');
				break;
			}
			i++;
		}
	},
	start: function start() {
		this.getData();
		console.log('source data:',JSON.stringify(this.data));
		this.makeTree();
		this.heapSort();
		this.echo();
		this.assert();
	},
	getNode(val, position) {
		var node = {};
		var count = this.COUNT;
		while(count) {
			node[count--] = null;
		}
		node.position = position;
		node.parent = null;
		node.pre = null;
		node.next = null;
		node.childs = 0;
		node.val = val;
		return node;
	}
}
new HeapSort().start();
```
算法正确性验证
```
var end = 10000;
var i = 0;
var time = setInterval(function() {
	if (i > end) {
		clearInterval(time);
	}
	i++;
	start();
	//new HeapSort().start();
},10)
```
算法性能比较
```
// 插入排序 
function insertSort(arr) {
for (var i = 1;i<arr.length;i++) {
var j=i-1;
var key = arr[i];
while (j>=0 && key<arr[j]) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = key;
}
}

// 希尔排序
function shellSortRecursion(arr,step) {
	if(step<1) {
		return;
	}
	for (var i = step;i<arr.length;i++) {
		var j = i-step;
		var key = arr[i];
		while (j>=0 && key<arr[j]) {
			arr[j+step] = arr[j];
			j-=step;
		}
		arr[j+step] = key;
	}
	step = Math.floor(step/2);
	shellSortRecursion(arr,step);
}

function start() {
	var data = getData();
	var start = new Date().getTime();
	var {root, startNode} = makeTree(data);
	heapSort(root, startNode);
	//insertSort(data)
	//shellSortRecursion(data,5)
	console.log((new Date().getTime() - start)/1000);
}
start();
```
复制代码


转载于:https://juejin.im/post/5c3e049f6fb9a049b22223fb

JavaScript实现大根堆（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-23 84
JavaScript实现大根堆（附完整源码）
最大堆JS实现
weixin_45847735的博客
12-06 716
由于在力扣刷题时遇到了最小的k个数，该题可以使用最大堆解决。 二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。 二叉堆有两种：最大堆和最小堆。最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。 最大堆，又称大根堆（大顶堆）是指根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，属于二叉堆的两种形式之一。 要求： ①根节点的关键字既大于或等于左子树的关键字值，又大于或等于右子树的关键字值。 ②为完全二叉
js实现的大根堆算法（基于数组的二叉树）
weixin_34326179的博客
01-15 346
``` function buildHeap(data) { var i = Math.floor((data.length -1)/2); while(i) { transfer(data,i,data.length-1); i--; } transfer(data,i,data.length-1); } function transfer(data, i, l...
实现完全二叉树
C1494717147的博客
03-22 734
HP;
数据结构复习
apple_54886810的博客
03-02 915
线性表 1.顺序表L删除所有值为x的元素，时间复杂度O(n),空间复杂度O(1) void delx(SqlList* L,ElemType x){ i=0,j=0; while(i<L->last){ if(L->elem[i]!=x){ L->elem[j]=L->elem[i]; i++,j++; }else{ i++; } }
数据结构PTA
Zhang_2002_GZ的博客
02-24 4370
title: 曲师大计院20级的PTA categories: - 数据结构 tags: - PTA toc: true 第一章 绪论 判断题 1-1 数据元素是数据的最小单位。F(数据项) 1-2 数据的逻辑结构是指数据的各数据项之间的逻辑关系。F（数据元素之间） 1-3 数据结构概念包括数据之间的逻辑结构、数据在计算机中的存储方式和数据的运算三个方面。T 1-4 数据结构的抽象操作的定义与具体实现有关。F 1-5 算法和程序没有区别，在数据结构中二者是通用的。F 1.
尹成学院区块链 Go 学习大纲-取得大纲试看视频联系微信yinchengak48
尹成的技术博客
08-21 5014
所处阶段 主讲内容 技术要点 学习目标 第一阶段Go语言开发入门实战 1.Go语言介绍及开发环境搭建 1.Go语言是什么 2.Go语言优势 3.Go语言适合来做什么 4.Go语言安装和设置 5.标准命令概述 6.第一个Go语言程序 课程设计理念： 夯实基础，Go语言作为...
计算机考研面试汇总
this is my house
03-23 4528
数据结构 数据三要素----数据的：逻辑结构，存储结构，运算 时间复杂度–将算法中基本运算的执行次数的数量级作为时间复杂度。 顺序表有哪些缺点？（逻辑上相邻的元素，在物理位置上也相邻） 优点：顺序表支持随机存取，存储密度大 缺点：插入和删除元素需要移动大量的元素（近一半） 注意：动态分配内存并不是链式存储结构，依然属于顺序存储结构，支持随机存取方式，只是分配的空间大小在运行时动态决定。 链表有哪些缺点？（逻辑上相邻的元素，在物理位置上不一定相邻） 优点：便于插入删除等操作，只要改变指针就行。不用考虑溢出问题
JavaScript大根堆小根堆
qq_30542973的博客
12-22 1269
序言 最近在刷leetcode遇到一个名为【大根堆】的东西，首先我不太清楚这是什么，所以我不能改厨准确的定义；它是方法？或者一个阶梯思路？或者一个数据结构？或者是其他什么。因为这个名字广泛出现在各种题解中。比如： 215. 数组中的第K个最大元素 面试题 17.20. 连续中值 295. 数据流的中位数 … 既然这么多题出现【大根堆】，它应该很重要，而我又不会；所以我决定搞清楚它 堆 百度百科上说：堆通常是一个可以被看做一棵完全二叉树的数组对象 比如：数组array = [7,3,8,5,1,2] 数组
js 最大堆
雨落_倾城的博客
03-09 299
js 最大堆
js实现堆 大根堆排序 小根堆排序
mushroomLNL的博客
04-18 1218
首先我的得到的是一个无序数组 , 要先将其构造成最大堆 , 再用堆排序得到有序的数组 无序的数组 : num = [1, 6, 12, 4, 5, 7, 8, 8, 9, 10, 0] 构造最大堆 : heap = [12, 10, 8, 9, 6, 7, 1, 8, 4, 5, 0] 使用堆排序 : num = [0, 1, 4, 5, 6, 7, 8, 8, 9, 10, 12] 构造最大堆的实现方法: 使父节点不断下沉 , 找到比父节点大的子节点 , 交换它们的位置 , 直到到达叶节点( 没有子节点
js实现大根堆
最新发布
Miss Stone的博客
11-24 122
【代码】js实现大根堆。
用javascript实现最大堆
lifeqiuzhi521的博客
08-23 776
html> html lang="en"> head> meta charset="UTF-8"> title>Titletitle> head> body> script> var heapArray = [1,2,3,4,5,6];//这里构建的是最大堆 function buildMaxHeap(heapArray,allIndex) { va
js实现最大堆
我是谁的博客
02-16 1173
有两个原始操作用于保证插入或删除节点以后堆是一个有效的最大堆或者最小堆： shiftUp(): 如果一个节点比它的父节点大（最大堆）或者小（最小堆），那么需要将它同父节点交换位置。这样是这个节点在数组的位置上升。 shiftDown(): 如果一个节点比它的子节点小（最大堆）或者大（最小堆），那么需要将它向下移动。这个操作也称作“堆化（heapify）”。 shiftUp 或者 shiftDo...
js实现数据结构—堆（最大堆）
爱吃牛肉的政
10-22 3650
/** * 最大堆构造函数 * @class * @param {Array&amp;lt;number&amp;gt;} [initDataArray] 初始化数据 * @param {number} [maxSize=9999] 堆的最大容量 */ /** *如果i=0，节点i是根节点，否则节点i的父节点为(i-1)/2 *2*i+1左子节点 2*i+2 右子节点 */ function M...
数组实现的大根堆
TDC的专栏
06-18 1578
堆 一种树状的数据结构 大根堆 根节点是所有节点中数值最大的节点 父节点的值总比子节点大 基本操作 Insert 向堆中插入一个值 Update 更新 Heapify 堆化 RemoveTop 删除堆顶元素 GetTop 获得堆顶元素 辅助操作 获得父节点 获得左孩子 获得右孩子 获得当前容量 判断一个节点是否是叶子节点 交换2个节点的位置 数组大根堆 用数组实现的大根堆 作...
向上更新实现大根堆：插入与调整算法
"向上更新代码是堆排序算法中的关键步骤，它在实现堆数据结构时用于维护堆的特性，即满足大根堆（或小根堆）的定义。大根堆的特点是每个节点的值大于或等于其子节点的值，根节点总是最大的（或最小的）。向上更新的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值