排序算法 之 堆排序(heapsort)

(二叉)堆数据结构是一种数组对象,可以被视为一棵完全二叉树。树的每一层都是填满的,最后一层可能除外。

二叉堆有两种:最大堆和最小堆。

最大堆中,除了根节点以外的每个节点i,有A[PARENT(i)]>=A[i]。这样,堆中的最大元素就存放在根节点中。

最小堆中,除了根节点以外的每个节点i,有A[PARENT(i)]<=A[i]。这样,堆中的最小元素就存放在根节点中。

 

堆排序

堆排序的算法主要分为三个要素:

1、确保最大(最小)堆的特性:从某节点i开始,判断i与其两个子节点的大小关系,对于最大堆来说,i节点如果大于其两个子节点的值,则结束程序;若小于某一个,则找出最大的替换为父节点,并将小的换到子节点处,并对该节点重复以上操作。该操作可以将位于i位置的较小(较大)值替换到二叉树的低端。值得注意的是,该步骤仅仅是对一个节点的操作,是确保的最大(最小)特性的单元操作。建堆时,需要用循环重复本要素。

2、根据数组建堆:从数组的n/2 -1 到 0,依次对该元素进行要素1操作,以确保所建堆为最大(最小)堆。

3、堆排序:逐一将顶端元素替换到最低端,将最低端元素移动到树顶,并使heap_size减小,从而使被移到低端的该元素退出以后的堆操作。每次移动后,重新对树顶节点进行要素1操作,由于除树顶外,其他部分都已经符合最大(最小)堆特性,因此该步骤可以将树顶元素重新移动到低端,形成新的最大(最小)堆。重复以上操作,直至堆消失。则排序后的数组就是一个升序(降序)数组。

 

以下算法讨论以最大堆为例,排出的数组位升序,最小堆排序将max_heapify()函数做更改即可。

堆积排序
堆排序算法的演示。首先,将元素进行重排,以符合堆的条件。图中排序过程之前简单的绘出了堆树的结构。
分类排序算法
数据结构数组
最差时间复杂度O(nlogn)
最优时间复杂度O(nlogn)[1]
平均时间复杂度Θ(nlogn)
最差空间复杂度O(n) total, O(1)auxiliary
最佳算法不是
C实现

int parent(int i)
{
	return (i-1)/2;
}
int lchild(int i)
{
	return 2*i+1;
}
int rchild(int i)
{
	return 2*(i+1);
}
/*保持堆的性质*/
/*最大堆*/
void max_heapify(int A[], int i, int heap_size)
{
	int temp,largest;
	int l,r;
	l = lchild(i);
	r = rchild(i);
	if( ( l < heap_size ) && ( A[l] > A[i] ) )
		largest  = l;
	else
		largest  = i;
	if( ( r < heap_size ) && ( A[r] > A[largest] ) )
		largest = r;
	if( largest != i )
	{
		temp = A[i];
		A[i] = A[largest];
		A[largest] = temp;
		max_heapify(A,largest,heap_size);
	}
}
/*根据数组建堆*/
void built_heap(int A[], int length)
{
	int i;
	for( i = length/2 - 1; i >= 0; i--)		//对于A[n]来说,A[n/2 ... n-1]的元素,都是树中的叶子
											//建堆的过程是从叶子的上一层开始,逐次向上直至树顶
	{
		max_heapify(A,i,length);			//此处直接将数组长度传入
	}
}
/*堆排序算法*/
void heap_sort(int A[], int length)
{
	int i;
	int temp;
	int heap_size;
	heap_size = length;
	built_heap(A,length);
	for( i = length-1; i >= 1; i--)
	{
		temp = A[0];
		A[0] = A[i];
		A[i] = temp;
		heap_size--;
		max_heapify(A, 0, heap_size);
	}

}
测试文件&结果

#include <stdio.h>
#include <tchar.h>
#include <stdlib.h>
int _tmain(int argc, _TCHAR* argv[])
{
	int A[] = {1,6,2,11,8,19,123,5,22,10};
	heap_sort(A,10);
	for(int i = 0; i<10; i++)
		printf("%d ",A[i]);
	system("pause");
	return 0;
}
 



  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
选择排序算法: 1. 从数组选择最小的元素,将其放置在数组的起始位置。 2. 在剩余的元素选择最小的元素,将其放置在已排序元素的末尾。 3. 重复步骤2直到所有元素都已排序。 代码实现: ``` function selectionSort(arr) { for (let i = 0; i < arr.length - 1; i++) { let minIndex = i; for (let j = i + 1; j < arr.length; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } if (minIndex !== i) { [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; } } return arr; } ``` 堆排序算法: 1. 构建一个最大堆(或最小堆)。 2. 将堆顶元素与最后一个元素交换,然后将堆的大小减1。 3. 对新的堆顶元素进行堆化,重复步骤2和3直到堆的大小为1。 代码实现: ``` function heapSort(arr) { buildMaxHeap(arr); let heapSize = arr.length; for (let i = arr.length - 1; i > 0; i--) { [arr[0], arr[i]] = [arr[i], arr[0]]; heapSize--; maxHeapify(arr, 0, heapSize); } return arr; } function buildMaxHeap(arr) { const heapSize = arr.length; for (let i = Math.floor(heapSize / 2); i >= 0; i--) { maxHeapify(arr, i, heapSize); } } function maxHeapify(arr, i, heapSize) { const left = 2 * i + 1; const right = 2 * i + 2; let largest = i; if (left < heapSize && arr[left] > arr[largest]) { largest = left; } if (right < heapSize && arr[right] > arr[largest]) { largest = right; } if (largest !== i) { [arr[i], arr[largest]] = [arr[largest], arr[i]]; maxHeapify(arr, largest, heapSize); } } ``` 选择排序算法的时间复杂度为$O(n^2)$,堆排序算法的时间复杂度为$O(n\log n)$。虽然堆排序的时间复杂度比选择排序更优,但是堆排序的常数项较大,因此在实际应用需要根据具体情况选择合适的排序算法
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值