堆排序是一种选择排序,是不稳定的排序方法。
特点:
在排序过程中,将排序数组看成是一棵完全二叉树存储结构,利用完全二叉树中父节点和孩子节点之间的内在关系,在当前无序区中选择关键字最大(最小)的记录。
基本思想:
堆分大根堆和小根堆,大根堆是父节点比所有子节点都大,小根堆是父节点比所有子节点都小。下面以大根堆为例。
1、先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区。
2、再将关键字最大的的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].Keys <= R[n].Key。
3、由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n-1..n],且仍满足关系R[1..n-2].Keys <= R[n-1..n].Keys,同样要将R[1..n-2]调整为堆。
代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Test1
{
class Program
{
static void Main(string[] args)
{
#region 堆排序
int[] arr = new int[6] { 4, 9, 5, 1, 7, 3 };
//HeapSort.HeapSortFunction(arr);
HeapSortFunction(arr);
foreach (var item in arr)
{
Console.Write(item +" ");
}
#endregion
}
//堆排序算法(传递待排数组名,即:数组的地址。故形参数组的各种操作反应到实参数组上)
public static void HeapSortFunction(int[] array)
{
try
{
BuildMaxHeap(array); //创建大顶推(初始状态看做:整体无序)
for (int i = array.Length - 1; i > 0; i--)
{
Swap(ref array[0], ref array[i]); //将堆顶元素依次与无序区的最后一位交换(使堆顶元素进入有序区)
MaxHeapify(array, 0, i); //重新将无序区调整为大顶堆
}
}
catch (Exception ex)
{ }
}
///<summary>
/// 创建大顶推(根节点大于左右子节点)
///</summary>
///<param name="array">待排数组</param>
private static void BuildMaxHeap(int[] array)
{
try
{
//根据大顶堆的性质可知:数组的前半段的元素为根节点,其余元素都为叶节点
for (int i = array.Length / 2 - 1; i >= 0; i--) //从最底层的最后一个根节点开始进行大顶推的调整
{
MaxHeapify(array, i, array.Length); //调整大顶堆
}
}
catch (Exception ex)
{ }
}
///<summary>
/// 大顶推的调整过程
///</summary>
///<param name="array">待调整的数组</param>
///<param name="currentIndex">待调整元素在数组中的位置(即:根节点)</param>
///<param name="heapSize">堆中所有元素的个数</param>
private static void MaxHeapify(int[] array, int currentIndex, int heapSize)
{
try
{
int left = 2 * currentIndex + 1; //左子节点在数组中的位置
int right = 2 * currentIndex + 2; //右子节点在数组中的位置
int large = currentIndex; //记录此根节点、左子节点、右子节点 三者中最大值的位置
if (left < heapSize && array[left] > array[large]) //与左子节点进行比较
{
large = left;
}
if (right < heapSize && array[right] > array[large]) //与右子节点进行比较
{
large = right;
}
if (currentIndex != large) //如果 currentIndex != large 则表明 large 发生变化(即:左右子节点中有大于根节点的情况)
{
Swap(ref array[currentIndex], ref array[large]); //将左右节点中的大者与根节点进行交换(即:实现局部大顶堆)
MaxHeapify(array, large, heapSize); //以上次调整动作的large位置(为此次调整的根节点位置),进行递归调整
}
}
catch (Exception ex)
{ }
}
///<summary>
/// 交换函数
///</summary>
///<param name="a">元素a</param>
///<param name="b">元素b</param>
private static void Swap(ref int a, ref int b)
{
int temp = 0;
temp = a;
a = b;
b = temp;
}
}
}
运行结果:
时间复杂度:初始化建堆的时间复杂度为O(n),排序重建堆的时间复杂度为nlog(n),所以总的时间复杂度为O(n + nlogn) = O(nlogn)。在序列初始状态为堆的情况下比较次数显著减少,在序列有序或逆序的情况下比较次数不会发生明显变化。所以时间复杂度为:O(nlogn);
算法的稳定性:是不稳定的排序算法。
算法适用的场合:堆排序比较交换次数比快速排序多,所以平均而言比快速排序慢,那么绝大多数场合都应该使用快速排序而不是堆排序。
①、但是在取最大(小)优先级的元素,其时间复杂度为O(1)。
②、插入新的元素,过程相当于插入堆尾,然后进行堆调整。