第六章：堆排序

最新推荐文章于 2021-09-18 22:33:34 发布
原创 最新推荐文章于 2021-09-18 22:33:34 发布 · 1.6k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本章节深入探讨堆排序算法，首先介绍了堆的基本概念，包括最大堆与最小堆的特性，接着阐述了如何通过构建和调整堆来实现排序过程。通过对堆的插入、删除操作的解析，详细讲解了堆排序的逻辑步骤，最后通过实例展示了堆排序的效率和应用场景。


一、堆的基本概念


一般我们讲的堆都是二叉堆。
二叉堆简单地来说就是一个完全二叉树。
完全二叉树：从左到右、从上到下塞满的一颗二叉树。
满二叉树：每层都塞满的二叉树。

堆分为大根堆（每个父亲都比儿子大，其中根为最大的元素）、小根堆（每个父亲都比儿子小，其中根为最小的元素）。
某个节点的高度为从该节点到叶子节点经过的路径的长度，比如叶子节点的高度为0。

d叉堆：一个父亲有d个孩子的完全d叉树。

最大堆应用于
(1)进程调度、任务调度，每次提取一个优先级最高的进程或任务。
(2)优先级队列，每次提取一个优先级最高的元素，并且始终维持着优先级。


二、二叉堆的性质


1.给定一个节点的索引为i，则
        父亲节点为floor(i/2)，也可以i>>1来实现。
        左孩子节点为2*i，也可以用i<<1实现。
        右孩子节点索引为 2*i+1，也可以用(i<<1)+1。
一般来说这些函数都是用“宏”或“内联函数”来实现，在C++中inline，而在Java中用final实现。
2.给定一个节点，他为根的树的节点数目为n，则左子树最多有2n/3个节点。
 

3.在n个元素的堆中，叶子节点有ceil(n/2)个节点，其余有floor(n/2)。
4.在n个元素的堆中，高度为h至多有
各节点。
5.floor(n/2)+1，floor(n/2)+2，.....，n都是叶子节点。
6.高度为floor(logn)。


三、d叉堆的性质


其实二叉堆的一系列性质也是由d叉堆推出的。




 







三、d叉堆的实现

二叉堆的实现就不给出了，直接给出d叉最小堆和d叉最大堆的实现。

1.最小堆

import java.util.Arrays;

/**
 * d叉最小堆
 * @author xiazdong
 *
 */
public class D_MIN_HEAP {
	private static int MAX = Integer.MAX_VALUE;
	private int arr[];				
	private int d;					//d叉堆
	private int heap_size;			//目前堆的大小
	private int MEMORY_SIZE;		//能够存储的总数组大小
	public static void main(String[] args) {
		D_MIN_HEAP heap = new D_MIN_HEAP(2);
		for(int i=0;i<10;i++){
			heap.insert(i);
		}
		heap.print();
		heap.delete(1);
		heap.print();
	}
	/**
	 * 按层输出堆
	 */
	public void print() {
		int height = height();
		for(int h=0;h<=height;h++){
			System.out.print("第"+h+"层:");
			int begin = (int)((Math.pow(d, h)-1)/(d-1)+1);
			int end = (int)((Math.pow(d, h+1)-1)/(d-1));
			for(int j=begin;j<=heap_size&&j<=end;j++){
				System.out.print(arr[j]+" ");
			}
			System.out.println();
		}
	}
	/**
	 * 
	 * @param d d叉堆
	 */
	public D_MIN_HEAP(int d){
		this.d = d;
		heap_size = 0;
		MEMORY_SIZE = 1024;
		arr = new int[MEMORY_SIZE];
	}
	/**
	 * 返回堆的高度
	 * @return
	 */
	public int height(){
		return (int)(log(heap_size, d)+log(d-1, d));
	}
	/**
	 * 返回x的父亲节点的索引
	 * @param x
	 * @return
	 */
	public final int parent(int x){
		return (x + d - 2)/d;
	}
	/**
	 * 将第i个位置的内容删去
	 * @param i
	 * @return
	 */
	public void delete(int i){
		arr[i] = arr[heap_size];
		heap_size--;
		MIN_HEAPIFY(i);
		
	}
	/**
	 * 插入一个元素，并维持最大堆
	 * @param k
	 */
	public void insert(int k){
		heap_size++;
		arr[heap_size] = MAX;
		ensureCapacity(heap_size+1);
		DECREASE_KEY(heap_size,k);
		
	}
	//参考ArrayList实现
	private void ensureCapacity(int x){
		if(x>=(int)(MEMORY_SIZE)){	//自增长数组
			MEMORY_SIZE = MEMORY_SIZE * 2;	
			arr = Arrays.copyOf(arr, MEMORY_SIZE);	
			//newarr = Arrays.copyOf(oldarr,newlength);	
			//表示将oldarr的全部内容复制到newarr中，newarr的长度为newlength
		}
	}
	/**
	 * 将arr[x]=k
	 * @param x
	 * @param k
	 */
	public void DECREASE_KEY(int x, int k) {
		arr[x] = k;
		if(arr[x]<k){
			System.err.println("不需要DECREASE");
			return;
		}
		else{
			while(x>1&&arr[parent(x)]>arr[x]){
				swap(parent(x),x);
				x = parent(x);
			}
		}
	}
	/**
	 * 返回parent的第number个孩子的节点
	 * @param parent
	 * @param number
	 * @return
	 */
	public final int child(int parent,int number){
		return d * parent - d + 1 + number;
	}
	/**
	 * 提取最大元素，并维持最大堆
	 * @return
	 */
	public int EXTRACT_MIN(){
		int MIN = arr[1];
		arr[1] = arr[heap_size];
		MIN_HEAPIFY(1);
		return MIN;
	}
	private void MIN_HEAPIFY(int x){
		int smallest = x;
		for(int i=1;child(x, i)<=heap_size&&i<=d;i++){
			if(arr[child(x, i)]<arr[smallest]){
				smallest = child(x,i);
			}
		}
		if(smallest!=x){
			swap(smallest,x);
			MIN_HEAPIFY(smallest);
		}
	}
	/**
	 * 给出另一种交换的程序
	 * @param smallest
	 * @param x
	 */
	private void swap(int smallest, int x) {
		arr[smallest] = arr[smallest]^arr[x];
		arr[x] = arr[smallest]^arr[x];
		arr[smallest] = arr[smallest]^arr[x];
	}
	private final double log(double value, double base) {
		return Math.log(value) / Math.log(base);
	}
}



2.最大堆

import java.util.Arrays;

/**
 * d叉最大堆
 * @author xiazdong
 *
 */
public class D_MAX_HEAP {
	private static int MIN = Integer.MIN_VALUE;
	private int arr[];				
	private int d;					//d叉堆
	private int heap_size;			//目前堆的大小
	private int MEMORY_SIZE;		//能够存储的总数组大小
	public static void main(String[] args) {
		D_MAX_HEAP heap = new D_MAX_HEAP(2);
		for(int i=10;i>0;i--){
			heap.insert(i);
		}
		heap.print();
		heap.delete(1);
		heap.print();
	}
	/**
	 * 按层输出堆
	 */
	public void print() {
		int height = height();
		for(int h=0;h<=height;h++){
			System.out.print("第"+h+"层:");
			int begin = (int)((Math.pow(d, h)-1)/(d-1)+1);
			int end = (int)((Math.pow(d, h+1)-1)/(d-1));
			for(int j=begin;j<=heap_size&&j<=end;j++){
				System.out.print(arr[j]+" ");
			}
			System.out.println();
		}
	}
	/**
	 * 
	 * @param d d叉最大堆
	 */
	public D_MAX_HEAP(int d){
		this.d = d;
		heap_size = 0;
		MEMORY_SIZE = 1024;
		arr = new int[MEMORY_SIZE];
	}
	/**
	 * 返回堆的高度
	 * @return
	 */
	public int height(){
		return (int)(log(heap_size, d)+log(d-1, d));
	}
	/**
	 * 返回x的父亲节点的索引
	 * @param x
	 * @return
	 */
	private final int parent(int x){
		return (x + d - 2)/d;
	}
	/**
	 * 将第i个位置的内容删去
	 * @param i
	 * @return
	 */
	public void delete(int i){
		arr[i] = arr[heap_size];
		heap_size--;
		MAX_HEAPIFY(i);
		
	}
	/**
	 * 插入一个元素，并维持最大堆
	 * @param k
	 */
	public void insert(int k){
		heap_size++;
		arr[heap_size] = MIN;
		ensureCapacity(heap_size+1);
		INCREASE_KEY(heap_size,k);
		
	}
	//参考ArrayList实现
	private void ensureCapacity(int x){
		if(x>=(int)(MEMORY_SIZE)){	//自增长数组
			MEMORY_SIZE = MEMORY_SIZE * 2;	
			arr = Arrays.copyOf(arr, MEMORY_SIZE);	
			//newarr = Arrays.copyOf(oldarr,newlength);	
			//表示将oldarr的全部内容复制到newarr中，newarr的长度为newlength
		}
	}
	/**
	 * 将arr[x]=k
	 * @param x
	 * @param k
	 */
	public void INCREASE_KEY(int x, int k) {
		arr[x] = k;
		if(arr[x]>k){
			System.err.println("不需要INCREASE");
			return;
		}
		else{
			while(x>1&&arr[parent(x)]<arr[x]){
				swap(parent(x),x);
				x = parent(x);
			}
		}
	}
	/**
	 * 返回parent的第number个孩子的节点
	 * @param parent
	 * @param number
	 * @return
	 */
	public final int child(int parent,int number){
		return d * parent - d + 1 + number;
	}
	/**
	 * 提取最大元素，并维持最大堆
	 * @return
	 */
	public int EXTRACT_MAX(){
		int max = arr[1];
		arr[1] = arr[heap_size];
		MAX_HEAPIFY(1);
		return max;
	}
	private void MAX_HEAPIFY(int x){
		int largest = x;
		for(int i=1;child(x, i)<=heap_size&&i<=d;i++){
			if(arr[child(x, i)]>arr[largest]){
				largest = child(x,i);
			}
		}
		if(largest!=x){
			swap(largest,x);
			MAX_HEAPIFY(largest);
		}
	}
	private void swap(int largest, int x) {
		int temp = arr[largest];
		arr[largest] = arr[x];
		arr[x] = temp;
	}
	public double log(double value, double base) {
		return Math.log(value) / Math.log(base);
	}
}

五、堆排序概念


1964年Williams发明的，1992年Sedgewick发表了堆排序性能分析 "The analysis of heapsort"。
堆排序是原地(In-place sort)排序。







完全D叉树maxDHeap（大堆根 用深度为d的树）
qq_57065913的博客
11-13 499
一般采用2插树来实现大堆根 但不只于， #include<iostream> #include<queue> #include<string> using namespace std; class Empty{ private: string message; public: Empty(string str="The number of elements is 0") ; string what(...
【排序算法】第二章：选择排序----普通选择排序与堆排序的详解和对比
最新发布
从不依靠，从不寻找，非常沉默，非常骄傲。 你必须非常努力，才能看起来毫不费力。
04-28 1797
【含有 gif 动图演示】【含多种 算法性能对比】【排序算法存在意义】
二、排序方法之堆排序（数据结构）
仰之弥高，钻之弥坚
12-22 720
数据结构学习小结二——排序方法之堆排序，涉及到了最小堆和最大堆两种方法实现。
6，排序-堆排序
顾小笙的博客
06-10 292
这一部分来分析一下堆排序，也可以理解为二叉树排序，这里的堆分为两种，一种是大顶堆，一种是小顶堆，我们所有的排序方法都以升序为主，其实倒序原理也都差不多，所以这里我们主要分析的是大顶堆。大顶堆就是根节点不小于他的两个子节点，先看一下代码 上面代码中heapSort方法表示对数组进行排序，buildMaxHeap表示堆的构建，maxHeapfy表示堆的调整，包括每次截取数据的时候也都需要调整，截取数据就相当于把root节点截取，然后用最后的一个节点替换到root的位置，然后再进行调整。看代码可能不是很直观
堆
weixin_44266050的博客
02-16 182
文章目录题目1：问题 A: 算法10-10,10-11：堆排序题目2：问题 B: 序列合并思路AC代码题目3：问题 C: 合并果子（堆） 题目1：问题 A: 算法10-10,10-11：堆排序 http://codeup.cn/problem.php?cid=100000616&pid=0 #include<bits/stdc++.h> using namespace std;...
29、堆排序
wangjiaee的博客
05-12 172
思路： 1、首先是初始化堆，建立从小到大的升序堆，只需要保证父节点的值大于相邻的子节点值即可 2、将数组收尾换位置，确保最大的元素在数组的尾部。 3、此时从头部元素开始调整堆，使他满足从小到大的序列，以此执行2-3步，直到执行n-1次（n:数组的长度） 代码： package heap; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; public class Heap
第七章：外部排序-20211
08-03
在本章“第七章：外部排序-20211”中，主要讲解了如何在磁盘文件或磁带文件等外部存储介质上进行排序。外部排序的主要挑战在于频繁的磁盘I/O操作，因为相比内存，磁盘的存取速度慢得多。 1. **外部排序的基本概念**...
【数据结构与算法】第八章：堆（最大堆、最小堆、堆排序、性能测试）
土味儿
09-18 753
8.1、定义 堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵 完全二叉树 的 数组对象 堆的特性 是 完全二叉树 除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的， 那么要求 左满右不满 通常用 数组 来实现 具体方法就是将二叉树的结点按照 层级顺序 放入数组中， 根结点在 位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推 如果一个结点的位置为 k，则它的父结点的位置为 k/2
精选资源
数据结构作业：第10章排序答案.docx
12-18
2. 堆排序： 堆排序是一种树形排序算法，它的基本操作是构建堆和堆调整。该算法的时间复杂度为O(nlog2n)，它适用于大规模的数据排序。 3. 快速排序： 快速排序是一种分治排序算法，它的基本操作是选择基准元素、...
数据结构（严蔚敏）第十章：内部排序
03-13
- **堆排序**：构造一个大顶堆或小顶堆，然后每次将堆顶元素与末尾元素交换，调整堆后继续这个过程。 - **快速选择/快速选择**：快速排序的变种，用于找出序列中第k小（大）的元素。 - **归并插入排序**：在归并...
十大排序算法总结 # 待完善
AudreyQCb的博客
08-06 419
先提前约定交换函数： protected void swap(int[] nums, int i, int j){ int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } 一、选择排序 思路： 从数组中选择最小元素，将它与数组的第一个元素交换位置。再从数组剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。 不断进行这样的操作，直到将整个数组排序。 复杂度： n个元素，第一次排序需要比较n-1次，第二次排序需要比
堆习题整理
qq_43732110的博客
05-18 427
堆模板 AcWing 839. 模拟堆 #include<bits/stdc++.h> using namespace std; const int N = 1e5+5; int n, h[N], Size, cnt; //ph[x]表示第x次插入的元素在堆中的下标为ph[x] //hp[x]表示在堆中下标为x的元素是第hp[x]次插入的 int ph[N], hp[N]; void swapall(int u, int t){ //交换两者对应插入顺序的所在位置 swa
第六章 堆排序
weixin_30537391的博客
06-09 98
以后尽量能用迭代就别用递归啊，递归只是让自己轻松了，但是却增加了电脑的负担。 package chap06_Heap_Sort; import static org.junit.Assert.*; import java.util.Arrays; import org.junit.Test; public class SortAlorithms { /**...
数据结构——【十五套卷子】考前题型归纳整理
刘鑫磊
06-14 3万+
一：选择题 1.用链接方式存储的队列，在进行插入运算时(D). A. 仅修改头指针 　 B. 头、尾指针都要修改 C. 仅修改尾指针 D.头、尾指针可能都要修改 注意2：二维数组二维数组变化 设有一个二维数组A[m][n]，假设A[0][0]存放位置在644(10)，A[2][2]存放位置在676(10)，每个元素占一个空间，问A[3][3](10)存放在什么位置？脚注(10)表示用10进制表示。C ...
任务调度(Schedule)-（优先队列->建堆）
信仰.的博客
02-14 3735
描述 某高性能计算集群（HPC cluster）采用的任务调度器与众不同。为简化起见，假定该集群不支持多任务同时执行，故同一时刻只有单个任务处于执行状态。初始状态下，每个任务都由称作优先级数的一个整数指定优先级，该数值越小优先级越高；若优先级数相等，则任务名ASCII字典顺序低者优先。此后，CPU等资源总是被优先级数最小的任务占用；每一任务计算完毕，再选取优先级数最小下一任务。不过，这里的任务在
算法导论第6章习题
weixin_30505225的博客
08-04 431
Exercises 6.1-1 2^h~2^{h+1}-1，如果root是第1个，而不是第0个。 6.1-2 设heap高度为h，2^h<=n<=2^{h+1}-1，取对数得到\floor{lgn} 6.1-3 传递性, Cormen用的是反证法 6.1-4 因为smallest element在heap中没有children，所以只能在leaf 6.1-5 YES...
第六章 堆排序习题
u012889441的博客
02-19 1万+
6.1堆 堆节点的高度：为该节点到叶节点最长简单路径上#边的个数#。（因此，根节点所在位置高度为0） 6.1-1 在高度为h的堆中，元素个数最多和最少分别是多少？最多：2h+1−1最少：2h最多：2^{h+1}-1 \\最少：2^h6.1-2 证明：含n个元素的堆的高度为⌊lgn⌋\lfloor \lg n \rfloor。证明：1）利用上面式子反推 2）数学归纳法证明即可 6.1-3
九大排序算法再总结
热门推荐
xiazdong
01-03 30万+
如果要转载，需要注明出处： http://blog.youkuaiyun.com/xiazdong 本文是 http://blog.youkuaiyun.com/xiazdong/article/details/7304239 的补充，当年看了《大话数据结构》总结的，但是现在看了《算法导论》，发现以前对排序的理解还不深入，所以打算对各个排序的思想再整理一遍。 本文首先介绍了基于比较模型的排序算法，
Dijkstra、Bellman_Ford、SPFA、Floyd算法复杂度比较
xiazdong
11-17 4万+
Dijkstra：适用于权值为非负的图的单源最短路径，用斐波那契堆的复杂度O(E+VlgV) BellmanFord：适用于权值有负值的图的单源最短路径，并且能够检测负圈，复杂度O(VE) SPFA：适用于权值有负值，且没有负圈的图的单源最短路径，论文中的复杂度O(kE)，k为每个节点进入Queue的次数，且k一般但此处的复杂度证明是有问题的，其实SPFA的最坏情况应该是O(VE). Flo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值