排序算法之堆排序

一：什么是堆

堆是一种数据结构，一种叫做完全二叉树的数据结构。

1.1、堆的性质

大根堆：每个节点的值都大于或者等于它的左右子节点的值。

小根堆：每个节点的值都小于或者等于它的左右子节点的值。

我们对上面的图中每个数都进行了标记，上面的结构映射成数组就变成了下面这个样子

那么这种堆结构，我们实际上是可以使用数组来进行存储表示的。

通过观察，我们可以发现如下规律：
查找数组中某个数的父结点和左右孩子结点，已知索引为 i ，那么

1.父结点索引：(i-1)/2

2.左孩子索引：2*i+1

3.右孩子索引：2*i+2

那么我们就可以得到下面的重要规律：

对于大根堆：arr[i] >= arr[2i + 1] && arr[i] >= arr[2i + 2]

对于小根堆：arr[i] <= arr[2i + 1] && arr[i] <= arr[2i + 2]

二：堆排序的实现（手写代码）

2.1、基本思想：

1.首先将待排序的数组构造成一个大根堆，此时，整个数组的最大值就是堆结构的顶端

2.将顶端的数与末尾的数交换，此时，末尾的数为最大值，剩余待排序数组个数为n-1

3.将剩余的n-1个数再构造成大根堆，再将顶端数与n-1位置的数交换，如此反复执行，便能得到有序数组

2.2、代码实现-Java

    public static void heapSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = arr.length - 1; i >= 0; i--) {
			heapify(arr, i, arr.length);
		}
		int heapSize = arr.length;
		swap(arr, 0, --heapSize);
		while (heapSize > 0) { 
			heapify(arr, 0, heapSize); 
			swap(arr, 0, --heapSize); 
		}
	}
	
	// arr[index]位置的数，能否往下移动
	public static void heapify(int[] arr, int index, int heapSize) {
		int left = index * 2 + 1; // 左孩子的下标
		while (left < heapSize) { // 下方还有孩子的时候
			// 两个孩子中，谁的值大，把下标给largest
			// 1）只有左孩子，left -> largest
			// 2) 同时有左孩子和右孩子，右孩子的值<= 左孩子的值，left -> largest
			// 3) 同时有左孩子和右孩子并且右孩子的值> 左孩子的值， right -> largest
			int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
			// 父和较大的孩子之间，谁的值大，把下标给largest
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index * 2 + 1;
		}
	}

	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

测试

    public static void main(String[] args) {
        int[] arr = {9,2,3,5,2,1};
        int[] ints = heapSort(arr);
        for (int i = 0 ; i<ints.length; i++){
            System.out.println(ints[i]);
        }
    }

三：优先级队列（系统堆结构）

Java中也有堆结构的具体实现，是优先级队列PriorityQueue，它的底层就是堆结构的实现，而且默认构建的是小根堆

        //默认是小根堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        heap.add(5);
        heap.add(1);
        heap.add(3);
        heap.add(8);
        heap.add(6);
        heap.add(1);
        heap.add(3);

        while (!heap.isEmpty()){
            System.out.println(heap.poll());
        }

使用比较器可以改变它的默认构造方式，将它变成大根堆

    public static class MyCom implements Comparator<Integer> {

        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    }
    
    PriorityQueue<Integer> heap = new PriorityQueue<>(new MyCom());

四：系统堆结构 VS 手写堆结构

看到这里可能有同学会想了：
既然系统已经给我们提供了堆结构的API，而且使用比较器也可以很方便的改变比较方式。
那么我们为什么还要手写堆结构来进行排序呢？？

原因就在于，系统提供的API不能实现动态改信息的需求。
1)系统提供的堆结构，如果动态的改变数据，它就不能保证结构依然有序。

2)手写的堆结构，因为增加了对象的位置表，所以能够满足动态改信息的需求。

下面举个例子，把六个学生按照年龄有小到大的顺序排序


结果：

很显然无序

为什么，手写的堆结构就不会发生这种问题呢？
原因就在于，系统的堆结构没有反向表HashMap（HashMap<T, Integer> indexMap; 任何你给我的数据样本，反向表都记录着该数据样本在堆上的具体位置），当样本的数据发生动态变化时，系统的堆结构不能够准确的找到该数据样本的位置，从而在数据改变后不能再继续进行堆排序，所以就会造成排序混乱。

但是手写的堆结构，因为我们是用数组进行实现的，所以我们清楚的记录着每个数据样本的位置，所以在数据改变后，我们依然能够找到这个数据并再继续进行堆排序。