2020-11-28

于 2020-12-03 10:39:48 发布
阅读量367 收藏
点赞数
分类专栏： Java数据结构与算法 文章标签： 数据结构 java 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Prestigious/article/details/110294479
版权

堆

1、堆的定义

堆是一棵完全二叉树，并且堆中每一个节点的值都必须大于等于（或者小于等于）其子树的每个节点的值。

2、堆的分类

大顶堆：堆中任一节点的值都大于等于子树中的节点值。
小顶堆：堆中任一节点的值都小于等于子树中的节点值。
在这里插入图片描述

3、堆的存储结构

因为堆是一棵完全二叉树，因此使用顺序结构（数组）存储更好！
回忆前面二叉树内容 二叉树两种存储方式：
如下图为大顶堆的存储：

在这里插入图片描述

4、堆的基本操作

4.1、向堆中插入元素【自底向上堆化】

参考链接：堆的原理与实现

如下图的大顶堆，当数组尾部插入元素15后，破坏了大顶堆的性质，因此必须重新调整（和AVL树失衡后调整一样的道理）
在这里插入图片描述
发现15>父节点9，交换二者。
在这里插入图片描述
又发现交换后的15>父节点14，再次交换二者。
在这里插入图片描述
最后15<父节点18，满足大顶堆。

4.2、删除堆顶元素【自顶向下堆化】

（1）、一种错误思路：删除堆顶元素，即用第二大元素（第二层左右子树中最大元素）替代，依次迭代下去。错误原因在于：最后形成的不是完全二叉树。
（2）、正确操作：将数组最后一个元素替代堆顶元素；再判断此时是否为大顶堆（堆顶与左右子树比较并交换，依次迭代）
如下图：删除大顶堆的堆顶元素18，先让最后元素9替代它。
在这里插入图片描述
在这里插入图片描述
此时形成的不是大顶堆，要调整。
在这里插入图片描述
在这里插入图片描述
分析后可知，堆的插入、删除时间复杂度为O(log n)，取决于完全二叉树的高度。

public class Heap {
	// 存放堆内元素的数组【从下标1开始存储元素，方便计算】
	private int data[];
	// 堆内存储元素最多个数
	private int MAXSIZE;
	// 堆内已经存储元素的个数
	private int count;

	public Heap() {
		this.data = new int[11];
		this.count = 0;
		this.MAXSIZE = 10;
		this.data[0] = Integer.MAX_VALUE;// 避免插入元素时，data[0]=0参与比较
	}

	public Heap(int capacity) {
		this.data = new int[capacity + 1];// 从下标1开始存储堆内元素
		this.count = 0;
		this.MAXSIZE = capacity;
		this.data[0] = Integer.MAX_VALUE;
	}

	public int[] getData() {
		return data;
	}

	public void setData(int[] data) {
		this.data = data;
	}

	public int getMAXSIZE() {
		return MAXSIZE;
	}

	public void setMAXSIZE(int mAXSIZE) {
		MAXSIZE = mAXSIZE;
	}

	public int getCount() {
		return count;
	}

	public void setCount(int count) {
		this.count = count;
	}

	/* 向堆Heap中插入元素value，使其仍然为一个大顶堆，这个过程称为堆化。
	 * 	第一步：将元素插入数组尾部；
	 *  第二步：如果插入节点<父节点，则交换二者；一直重复此操作直到形成大/小顶堆。
	*/
	public static boolean insertHeap(Heap heap, int value) {
		if (heap.count == 0) {// 当前堆为空
			System.out.println("当前堆为空,新插入元素为:" + value);
			heap.data[1] = value;
			heap.count = 1;
			return true;
		}

		int length = heap.data.length;
		int count = heap.count;// 堆内元素个数

		if (length - count == 1) {
			System.out.println("堆已满，要扩容");
			return false;
		}

		// 正常插入时：heap.data[++count] = value，但是可能会破坏大顶堆

		heap.data[++heap.count] = value;// 插入元素，数组长度+1

		// 开始判断插入元素后是否还满足大顶堆性质
		int j = heap.count;
		while (j > 0 && (heap.data[j] > heap.data[j / 2])) {
			int temp = heap.data[j];
			heap.data[j] = heap.data[j / 2];
			heap.data[j / 2] = temp;

			j = j / 2;
		}

		return true;
	}

	/*
	 * 删除堆顶元素：
	 * 	  第一步：让数组最后一个元素替代堆顶元素；
	 * 	  第二步：此时堆顶元素与左右子树判断，是否符合大顶堆。
	 */
	public static boolean deleteHeap(Heap heap) {
		if (heap.count == 0) {
			System.out.println("堆内没有元素了，不能珊瑚");
			return false;
		}

		heap.data[1] = heap.data[heap.count];
		heap.data[heap.count] = 0;
		heap.count--;// 替换并删除

		// 开始判断替换后的堆顶元素是否还满足大顶堆性质
		int j = 1;
		while (j < heap.count && (heap.data[j] < heap.data[j * 2] || heap.data[j] < heap.data[j * 2 + 1])) {
			int leftValue = heap.data[j * 2];// 左子树值
			int rightValue = heap.data[j * 2 + 1];// 右子树值

			if (leftValue > rightValue) {
				int temp = heap.data[j];
				heap.data[j] = heap.data[j * 2];
				heap.data[j * 2] = temp;
				j = j * 2;
			} else {
				int temp = heap.data[j];
				heap.data[j] = heap.data[j * 2 + 1];
				heap.data[j * 2 + 1] = temp;
				j = j * 2 + 1;
			}
		}
		return true;
	}

	// 打印堆内元素
	public static void printHeap(Heap heap) {
		for (int i = 1; i <= heap.count; i++) {
			System.out.print(heap.data[i] + "  ");
		}
		System.out.println("\n--------------打印结束---------------");
	}

	public static void main(String[] args) {
		Heap heap = new Heap();
		// insertHeap(heap, 20);
		// insertHeap(heap, 10);
		// insertHeap(heap, 15);
		// insertHeap(heap, 18);// 调整
		// insertHeap(heap, 16);
		// insertHeap(heap, 12);
		// insertHeap(heap, 8);
		// insertHeap(heap, 30);// 调整
		// printHeap(heap);
		//
		// deleteHeap(heap);// 删除堆顶元素30
		// printHeap(heap);

		// insertHeap(heap, 20);
		// insertHeap(heap, 10);
		// insertHeap(heap, 16);
		// insertHeap(heap, 5);
		// insertHeap(heap, 15);
		// printHeap(heap);
		// deleteHeap(heap);// 删除堆顶元素20
		// printHeap(heap);

		insertHeap(heap, 10);
		insertHeap(heap, 5);
		insertHeap(heap, 8);
		insertHeap(heap, 20);
		insertHeap(heap, 15);
		insertHeap(heap, 16);
		insertHeap(heap, 30);
		printHeap(heap);
	}
}

5、堆的应用之堆排序

参考链接：图解堆排序算法
（1）、堆排序的基本思想是：将待排序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
（2）、堆排序步骤：
第一步、构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
第二步：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

/*
 * 堆排序：
 * 	第一步：构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
 *  第二步：将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
 */
public class HeapSort {

	/*
	 * copy的Heap类代码，这里就不改为插入数组了
	 */
	public static boolean insertHeap(Heap heap, int value) {
		if (heap.getCount() == 0) {// 当前堆为空
			System.out.println("当前堆为空,新插入元素为:" + value);
			heap.setContent(heap, 1, value);
			heap.setCount(1);
			return true;
		}

		int length = heap.getData().length;
		int count = heap.getCount();// 堆内元素个数

		if (length - count == 1) {
			System.out.println("堆已满，要扩容");
			return false;
		}

		heap.setCount(heap.getCount() + 1);
		heap.setContent(heap, heap.getCount(), value);// 插入元素，数组长度+1

		// 开始判断插入元素后是否还满足大顶堆性质
		int j = heap.getCount();
		while (j >= 1 && (heap.getData()[j] > heap.getData()[j / 2])) {
			int temp = heap.getData()[j];
			heap.getData()[j] = heap.getData()[j / 2];
			heap.getData()[j / 2] = temp;

			j = j / 2;
		}

		return true;
	}

	/*
	 * 给大顶堆Heap排序：将堆顶元素与末尾元素进行交换，使末尾元素最大
	 */
	public static int[] sort(Heap heap) {

		int srotedHeap[] = new int[heap.getCount()];// 返回排序后的数组

		for (int i = heap.getCount(); i >= 1; i--) {

			srotedHeap[i - 1] = heap.getData()[1];// 当前最大元素

			heap.setContent(heap, 1, heap.getData()[i]);
			heap.setContent(heap, i, 0);

			// 开始判断替换后的堆顶元素是否还满足大顶堆性质
			int j = 1;
			while (j < (i - 1)
					&& (heap.getData()[j] < heap.getData()[j * 2] || heap.getData()[j] < heap.getData()[j * 2 + 1])) {
				int leftValue = heap.getData()[j * 2];// 左子树值
				int rightValue = heap.getData()[j * 2 + 1];// 右子树值

				if (leftValue > rightValue) {
					int tempValue = heap.getData()[j];

					heap.setContent(heap, j, heap.getData()[j * 2]);

					heap.setContent(heap, j * 2, tempValue);
					j = j * 2;
				} else {
					int tempValue = heap.getData()[j];

					heap.setContent(heap, j, heap.getData()[j * 2 + 1]);

					heap.setContent(heap, j * 2 + 1, tempValue);
					j = j * 2 + 1;
				}
			}
		}

		return srotedHeap;
	}

	public static void main(String[] args) {
		// int data[] = new int[] { 10, 8, 6, 7, 5 };
		int data[] = new int[] { 20, 10, 15, 8, 30, 12, 5, 4, 3, 2, 50, 25, 100 };

		Heap heap = new Heap(15);

		for (int i = 0; i < data.length; i++) {// 完成第一步：构建初始堆
			insertHeap(heap, data[i]);
		}
		heap.printHeap(heap);

		int[] sortedHeap = sort(heap);
		for (int i = 0; i < sortedHeap.length; i++) {
			System.out.print(sortedHeap[i] + "  ");
		}
	}
}
彩虹海ing
关注
专栏目录
堆排序
Ronz 的博客
01-21 799
文章目录一、堆排序概述1.1 什么是堆1.2 什么是堆排序1.3 堆排序的思想二、堆排序的步骤分析三、堆排序的代码实现 一、堆排序概述 1.1 什么是堆 堆（heap）是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做为一棵树的数组对象。 堆总是满足以下性质： 堆中的父节点的值总是小于（或者大于）它的子节点的值； 堆是一颗完全的二叉树。 根据父节点与子节点的大小关系，堆又可以分为最大堆和最小堆。 其中最大堆的父节点的值总是大于它的子节点的值；最小堆的父节点的值总是小于它的子节点的值。
2020-11-28 npm打包失败
wingsky666的博客
11-28 1794
问题： npm run build 然后就出问题了 ERROR TypeError: Class extends value undefined is not a constructor or null 参考 https://blog.csdn.net/u013938484/article/details/106259913 npm install webpack -g npm install webpack --save-dev 启动成功！ OK！ ...
Java堆排序
Ralph2048的博客
04-13 128
“堆” 这个词最初是在堆排序中提出的，但后来就逐渐指“废料手机存储区”，就像Java的堆一样，但这里的堆指的是排序。 （二叉）堆数据结构是一种数组对象，可以被视为一棵完全二叉树，树中每个节点与数组中存放该节点值的那个元素对应，树的每一层都是填满的，最后一层可能除外，堆中有两个属性：length[A]是数组中的元素个数，heap_size[A]是存放在A中...
白话讲排序系列（六） 堆排序（绝对让你明白堆排序！）
热门推荐
夜阑听风
03-09 6万+
开门见山，本文讲述堆排序。 就我自身对于排序的了解来看，其实堆排序是诸多排序中最难写的，光是理解起来都有点费劲，本文旨在于用通俗易懂的话，把堆排序娓娓道来。 下面，开始！ 1：堆 毫无疑问，排序两个字没必要去死磕，这里的重点，在于排序的方式，堆排序，就是以堆的形式去排序，毫无疑问，了解堆很重要。 那么，什么是堆呢？ 这里，必须引入一个完全二叉树的概念，然后过渡到堆的概念。 上图，...
ChipsBank(芯邦)CBM209X UMPToolV7200(2020-03-19)
05-02
ChipsBank(芯邦)APToolV7200(2020-05-20)CBM2099，CBM2199 相对新一点，这个型号的试了可以用。 显示是CBM2099，但实际上好像是CBM2199 　主控厂商: ChipsBank(芯邦) 　主控型号: CBM2099E - [2019-11-11]
Project_最小C51系统_2020-11-23_17-28-40_开发板PCB_立创EDAC51_
10-02
标题中的"Project_最小C51系统_2020-11-23_17-28-40_开发板PCB_立创EDAC51_"揭示了一个项目，专注于构建一个基于C51微控制器的最小系统。这个系统在2020年11月23日的特定时间进行了开发，并且与立创EDAC51开发板的...
芯邦量产工具2019-07到2020-09年所有的.zip
11-26
这款工具涵盖了2019年7月至2020年9月间的多个版本，反映了芯邦科技在这段时间内对U盘生产工具的持续更新与优化。 首先，我们来看CBM209X UMPToolV7200系列。这个系列的工具主要针对芯邦的CBM209X系列芯片，例如CBM...
1.3 Eclipse的下载与安装，J2EE版（2020-11-28）
bravery2288的博客
11-28 3012
1.3 Eclipse的下载与安装 一、eclipse下载 进入官网：https://www.eclipse.org/downloads/
INSERT INTO `借阅表` VALUES (100001,'123413','0001','2020-11-05',NULL,'借阅'), (100002,'223411','0002','2020-9-28',2020-10-13,'已还'), (100003,'321123','1001','2020-7-01',NULL,'过期'), (100004,'321124','2001','2020-10-09',2020-10-14,'已还'), (100005,'321124','0001','2020-10-15',NULL,'借阅'), (100006,'223411','2001','2020-10-16',NULL,'借阅'), (100007,'411111','1002','2020-9-01',2020-9-24,'已还'), (100008,'411111','0001','2020-9-25',NULL,'借阅'), (100009,'411111','1001','2020-10-08',NULL,'借阅');
最新发布
05-11
- 借阅编号：100002，读者编号：223411，书籍编号：0002，借阅日期：2020-9-28，归还日期：2020-10-13，借阅状态：已还 - 借阅编号：100003，读者编号：321123，书籍编号：1001，借阅日期：2020-7-01，归还日期：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值