堆排序实例

首先介绍一下堆结构，因为堆结构在逻辑概念与完全二叉树是一样的，比如我有一个长度为7的数组{4，7，2，8，1，2，9}，那么它对应的二叉树就是下面这样:

二叉树遵循从上到下，从左到右的顺序排列，只有一个元素也可以认为是一个完全二叉树；

但是不能左侧没值，例如上图中最后一行，跳过左侧2的分支(跳过左点)直接到9的分支就不是二叉树，但是如果最后一行9的分支不在，也构成二叉树结构。

上图是值构成的二叉树，下图是将值换成数组对应的下标构成的二叉树:

假设我们将上面从0出发的连续一段(对应数组中的4-9这7个数字，下标值对应0-6)数字对应:

记作变量size=7

如果现在有一个变量i，那如何取到二叉树中i对应的左子节点和右子节点，以及父节点呢？有公式如下:

左子节点:2*i+1；

右子节点:2*i+2；

父节点:(i-1)/2；

可以假设i=1，使用以上公式验证；注意:当算得的结果为小数时，自动取整。

堆分为大根堆与小根堆，以大根堆为例:

在整体中，最大值为6，而在5，3，2这个子树中，父值5最大；4，1，0子树中，4最大，满足这种规范则为大根堆，相反则为小根堆 。

在堆操作中，最重要的两个操作是:heapInsert和heapify，其他所有对堆的操作都是基于这两种操作演变而来。

heapInsert:

假定我们事先不知道有多少个元素，通过不断往堆里面插入元素进行调整来构建堆，步骤如下：

1.首先增加堆的长度，在最末尾的地方加入最新插入的元素。

2.比较当前元素和它的父结点值，如果比父结点值大，则交换两个元素，否则返回

3.重复步骤二。

图解如下(传入的参数为数组与整个数组的最大下标值):

 代码如下:

//某个数现在处在index位置，往上继续移动,这里实现将树中最大值放在第一位(用此方法实现大根堆)
	public static void heapInsert(int[] arr,int index) {
		while(arr[index]>arr[(index-1)/2]) {		//while循环条件:如果当前值大于父位置的值
			swap(arr,index,(index-1)/2);			//数组index位置值与父位置值做交换
			index = (index-1)/2;					//index来到交换完的位置(父位置)
		}
	}

heapify:

从最后一个非叶子节点一直到根结点进行堆化的调整。如果当前节点小于某个自己的子节点（大根堆中），那么当前节点和这个子节点交换。Heapify是一种类似下沉的操作，HeapInsert是一种类似上浮的操作。

图解如下(传入参数为整个数组，起始位置0，数组最大下标值):

代码如下:

//如果客户自定义一个位置(index),此方法确定在此位置(index)能否往下移动,并且往下移动
	public static void heapify(int[]arr,int index,int heapSize) {
		int left = index * 2 + 1;		//左子节点的下标(i*2+1)
		while(left < heapSize) {		//条件:下方还有子节点的时候,说明没越界
			//两个子节点中，谁的值大，把下标给largest
			int largest = left + 1 < heapSize && arr[left+1]>arr[left]		//如果右子节点(left+1)没越界,并且右子节点的值大于左子节点的值
					? left + 1 : left;										//就将右子节点的下标赋值给largest,否则将左子节点的下标赋值给largest
			
			//父节点和子节点之间，谁的值大，把下标给largest
			largest = arr[largest] > arr[index] ? largest : index;			//如果子节点(largest)节点的值大于父节点(index)的值,则将子节点下标赋值给largest,否则将父节点(index)值赋值给largest
			
			//经过以上两组的转换,实现父节点和子节点中,谁的值大就把谁的下标给到largest
			
			if(largest == index) {				//如果largest等于父节点,则说明在此树范围，父节点的值就是最大值,则跳出循环
				break;
			}
			swap(arr, largest, index);			//否则将子节点的值与父节点值做交换,largest与index是数组下标
			index = largest;					//将交换后的值赋给index,则父节点(index)就是此节点中最大值的位置
			left = index * 2 + 1;				//继续找到左子节点
		}
	}

 

非叶子节点与叶子节点:

 叶子节点:H,I,E,F,G

非叶子节点:A,B,C,D

树的深度:4

查找第一个非叶子节点:

如果根节点在数组中的索引为1，所以第一个非叶子节点的计算公式为: last_non_leaf = arr.length/2。

如果根节点在数组中的索引为0，那么第一个非叶子节点的计算公式为: last_non_leav = (arr.length - 2)/2

可以设最后一个非叶子节点位置为x，那么最后一个叶子节点一定是(2x+1) 或者(2x+2)中的一个，然后可以建立方程求解。

最后附上完整heapInsert，heapify与堆排序代码:

package com.mrz.test;

/*
 * 2022-04-02
 * mrz
 * 堆排序
 */
public class HeapSort {

	public static void main(String[] args) {
		int[] arr = {4,7,2,8,1,2,9};
		heapInsert(arr, arr.length-1);
		System.out.print("heapInsert操作结果:");
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i]);
		}
		
		System.out.println("\n");
		
		int[] acc = {4,7,2,8,1,2,9};
		heapify(acc, 0,acc.length-1);
		System.out.print("heapify操作结果:");
		for(int i = 0;i < acc.length;i++) {
			System.out.print(acc[i]);
		}
		
		//以上两个方法中,方法传入的参数都是指定的,如果修改了有效区域的其中某个节点的值,如何还是让此结构是大根堆或是小根堆呢?
		//例如修改的节点下标是i,之前的值为a,现在改成了?
		//如果i位置的值变小了,则如果还想结构是大根堆，就让i位置的数向下经历一次heapify
		//如果i位置值变大了,i位置的值就经历一次heapInsert调整
		//直接执行heapInsert方法或者heapify方法,如果前一个方法不成立则继续执行下一个方法,两个方法只能成立一个,最后整个结构必然是对的
		System.out.println("\n");
		
		heapSort(acc);
		System.out.print("堆排序(heapSort)操作结果:");
		for(int i = 0; i < acc.length;i++) {
			System.out.print(acc[i]);
		}
	}
	
	
	
	//堆排序方法(额外时间复杂度:O(logN);额外空间复杂度:O(1))
	public static void heapSort(int[] arr) {
		if(arr == null || arr.length < 2) {
			return;
		}
		for(int i = 0;i < arr.length; i++) {		//执行完这个循环结构就变成了大根堆
			heapInsert(arr, i);
		}
		int heapSize = arr.length;				//定义变量heapSize,值是数组长度
		swap(arr, 0, --heapSize);				//用交换位置的方法，将数组0位置的值与数组最后位置的值交换(因为数组经历了上面的循环是大根堆，所以就是将数组最大值和最小值交换位置)
		while(heapSize > 0) {					//循环条件:如果数组大小大于0,说明排序未结束
			heapify(arr, 0, heapSize);			//执行此方法,实现最大值放到放到0位置
			swap(arr, 0, --heapSize);			//将数组中0位置与数组最后一个位置换位(就是将最大值与数组最后一个值换位),实现数组从后向前按照从大到小排列。       注意:每次先自减是为了把上
												//次的最大值排除，否则就是一直0位置的值和最后位置的值交换位置,没意义
		}
	}
	
	
	
	
	
	//某个数现在处在index位置，往上继续移动,这里实现将树中最大值放在第一位(用此方法实现大根堆)
	public static void heapInsert(int[] arr,int index) {
		while(arr[index]>arr[(index-1)/2]) {		//while循环条件:如果当前值大于父位置的值
			swap(arr,index,(index-1)/2);			//数组index位置值与父位置值做交换
			index = (index-1)/2;					//index来到交换完的位置(父位置)
		}
	}
	
	
	
	
	
	
	
	//如果客户自定义一个位置(index),此方法确定在此位置(index)能否往下移动,并且往下移动
	public static void heapify(int[]arr,int index,int heapSize) {
		int left = index * 2 + 1;		//左子节点的下标(i*2+1)
		while(left < heapSize) {		//条件:下方还有子节点的时候,说明没越界
			//两个子节点中，谁的值大，把下标给largest
			int largest = left + 1 < heapSize && arr[left+1]>arr[left]		//如果右子节点(left+1)没越界,并且右子节点的值大于左子节点的值
					? left + 1 : left;										//就将右子节点的下标赋值给largest,否则将左子节点的下标赋值给largest
			
			//父节点和子节点之间，谁的值大，把下标给largest
			largest = arr[largest] > arr[index] ? largest : index;			//如果子节点(largest)节点的值大于父节点(index)的值,则将子节点下标赋值给largest,否则将父节点(index)值赋值给largest
			
			//经过以上两组的转换,实现父节点和子节点中,谁的值大就把谁的下标给到largest
			
			if(largest == index) {				//如果largest等于父节点,则说明在此树范围，父节点的值就是最大值,则跳出循环
				break;
			}
			swap(arr, largest, index);			//否则将子节点的值与父节点值做交换,largest与index是数组下标
			index = largest;					//将交换后的值赋给index,则父节点(index)就是此节点中最大值的位置
			left = index * 2 + 1;				//继续找到左子节点
		}
	}
	
	
	
	
	
	//每次循环后都将最小值放在第一位，后续只循环除第一位(最小数据)之后的数据
	public static void swap(int arr[],int i,int j) {
		//将每次循环的第一位记录
		int tmp = arr[i];
		//将j下标(本轮循环最小值)放在数组第一位
		arr[i] = arr[j];
		//将每次循环的第一位放在原本最小值的位置(换位)
		arr[j] = tmp;
	}
	
	
	
	
}