数据结构 —— 堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏、最好平均时间复杂度均为O(nlogn)，是不稳定排序。

堆是具有以下性质的完全二叉树：
每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆；
每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。

注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系

举个栗子：  现要排序数据 “ 5， 7， 4， 2， 0， 3， 1， 6 ”，

堆排序流程：

（1） 利用完全二叉树构建大顶堆

首先，将数据构成完全二叉树，如下图：

完全二叉树： 要求数据从上到下，从左到右的顺序进行排序

接着，构建大顶堆，如下图：

大顶堆：父节点的值大于或等于其左右孩子的值

（2） 堆顶元素和堆底元素进行互换，堆底元素不再参与构建

（3） 不断重复前面两个步骤

 

构建大顶堆

1. 定义parent游标，parent游标从后向前移动，直到找到有孩子的节点
   

    

2. 定义child游标，指向parent的左孩子，判断child是否为空（有孩子一定会有左孩子，因为是一棵完全二叉树）
   

3. 如果左孩子不为空，就判断是否存在右孩子。
   如果有右孩子，就让左右孩子进行对比，child游标指向左右孩子当中的最大值。

4.  父节点和子节点进行对比。

   如果父节点的值大，parent游标继续向前移动；

   如果子节点的值大，父子节点的值进行交换，父节点指向子节点，子节点指向其左右孩子的最大值；

   如果child没有孩子，那parent就不再向下指。

5. 不断重复2-4步骤

堆顶元素和堆底元素进行互换

堆底元素不再参与构建，其余元素继续构建大顶堆。

parent游标从堆顶开始，child游标指向其左右孩子的最大值。

时间复杂度：

时间复杂度 = 轮数 * 每一轮的时间复杂度 = O(nlogn)

轮数：n

每一轮的时间复杂度：k = log2n

 代码实现：

import java.util.Arrays;



/**
 * 堆排序
 * @author Yangyeon
 *
 */
public class Heapsort {
	public static void main(String[] args) {
		int[] arr = new int[] {5,7,4,2,0,3,1,6};
		for(int p=arr.length-1; p>=0; p--) {
			adjust(arr,p,arr.length);
		}
		
		//堆顶和堆底交换过程
		for(int i=arr.length-1; i>=0; i--) {
			exchange(arr, i, 0);
			adjust(arr,0,i);
		}
		
		System.out.println(Arrays.toString(arr));
	}
	
	public static void adjust(int[] arr, int parent, int length) {
		//根据完全二叉树的父节点、孩子节点关系
		int child = 2*parent + 1 ;
		
		//左孩子存在时
		while(child<length) {
			int rchild = child + 1;
			
			//右孩子结点存在且左孩子的值小于右孩子的值时
			if(rchild<length && arr[rchild]>arr[child]) {
				child++;  //child游标指向右孩子
			}
			//父节点的值小于孩子节点的值时
			if(arr[parent]<arr[child]) {
				exchange(arr, child, parent);
				parent = child;
				child = 2*child + 1;
			}else {
				break;
			}
		}
	}
	
	public static void exchange(int[] arr,int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
}