排序算法之堆排序--Java语言

堆排序算法首先将所有元素(从未排序的数组)插入堆中，然后从堆的根节点依次删除，直到堆空为止。本文主要利用现有数组进行就地排序，具体做法是，当删除一个元素时，只是将数组中的第一个元素与最后一个元素交换位置而不是移除，同时减小堆的大小，即数组大小，然后再对第一个元素进行堆化。持续这个过程直到剩余元素为1.

在数组中直接进行堆排序，需要知道几个参数，即最后一个元素的位置是i=count-1，count为数组大小，则最后一个元素的双亲位置为(count-1)/2。任意一个节点j的左子节点位置l=2*j+1，右子节点位置r=2*j+2.

代码：

public class HeapSort {
	public static void swap(int[] data,int i,int j)
	{
		if(i==j)
			return;
		data[i]=data[i]+data[j];
		data[j]=data[i]-data[j];
		data[i]=data[i]-data[j];
	}
	
	public static int[] heapSort(int[] data)
	{
		for(int i=0;i<data.length;i++)//控制堆大小。
		{
			//每次遍历创建最大堆，并且将堆顶元素放至最后一个，并将遍历的最后一位位置逐个左移。
			createMaxHeap(data,data.length-1-i);//堆化
			swap(data,0,data.length-1-i);//交换第一个元素与最后一个元素，即获取当前最大值
			print(data);
		}
		return data;
	}
	
	public static void createMaxHeap(int[] data,int lastIndex)
	{
		for(int i=(lastIndex-1)/2;i>=0;i--)
		{
			//保存当前正在判断的节点
			int k=i;
			//若当前节点存在
			while(2*k+1<=lastIndex)
			{
				//biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点
				int biggerIndex=2*k+1;
				if(biggerIndex<lastIndex)
				{
					//若右子节点存在，否则此时biggerIndex应该等于lastIndex
					if(data[biggerIndex]<data[biggerIndex+1])
					{
						//若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值
						biggerIndex++;
					}
				
				}
				if(data[k]<data[biggerIndex])
				{
					//若当前节点值比子节点最大值小，则交换两者的值，交换后将biggerIndex值赋给k
					swap(data,k,biggerIndex);
					k=biggerIndex;
				}
				else
					break;
			}
		}
	}
	
	public static void print(int[] data)
	{
		for(int i=0;i<data.length;i++)
			System.out.print(data[i]+" ");
		System.out.println();
	}
	
	public static void main(String[] args)
	{
		int[] data= {89, 66, 39, 78, 40, 56, 3, 13, 20, 95};
		System.out.println("堆排序的序列变化：");
		int[] ans=heapSort(data);
		System.out.println("堆排序后的序列：");
		for(int i=0;i<data.length;i++)
			System.out.print(data[i]+" ");
	}

}

测试结果：

堆排序的序列变化：
40 89 56 78 66 39 3 13 20 95 
20 78 56 40 66 39 3 13 89 95 
13 66 56 40 20 39 3 78 89 95 
3 40 56 13 20 39 66 78 89 95 
3 40 39 13 20 56 66 78 89 95 
3 20 39 13 40 56 66 78 89 95 
13 20 3 39 40 56 66 78 89 95 
3 13 20 39 40 56 66 78 89 95 
3 13 20 39 40 56 66 78 89 95 
3 13 20 39 40 56 66 78 89 95 
堆排序后的序列：
3 13 20 39 40 56 66 78 89 95 

堆排序主要是堆化的过程，堆化过程中的时间复杂度为O(nlogn)，所以堆排序的时间复杂度为O(nlogn)。堆排序是一种就地排序，不需要额外的辅助空间，同时由于在堆化的过程中，元素比较交换次数较多，排序算法不稳定。