Java数据结构——堆排序_java 堆排序数据结构

一、堆排序

（一）、什么是堆排序

• 知识卡片：

1. 堆排序（HeapSort）。
2. 堆排序是指利用堆这种数据结构所设计的一种排序算法。
3. 堆是一种数据结构，一种叫做完全二叉树的数据结构。
4. 升序采用大顶堆，降序采用小顶堆
1
2
3
4
5

• 堆：

1. 这里我们用到两种堆，其实也算是一种:
2. 大顶堆：每个节点的值都大于或者等于它的左右子节点的值。
3. 小顶堆：每个节点的值都小于或者等于它的左右子节点的值。
1
2
3

• 原理：

1. 利用堆的概念来排序的选择排序
1

• 算法：

1. 初始化一个堆，完全二叉树
2. 将堆顶元素与末尾元素进行交换
3. 重新对堆进行调整
1
2
3

• 性能：

1. 初始化建堆的时间复杂度为O(n)
2. 排序重建堆的时间复杂度为O(nlogn)
3. 所以总的时间复杂O(n+nlogn)=O(nlogn)
1
2
3

（二）、图例

（三）、Java代码

• heapSort

	/**
	 * 堆排序
	 * 
	 * @param arrs
	 */
	public void heapSort(int[] arrs) {
		int n = arrs.length;
		
		// 1. 构建大顶堆——升序
		for(int i=n/2-1; i>=0; i--) {
			adjustHeap(arrs, i, n);
		}
		
		// 2. 堆排序
		for(int i=n-1; i>0; i--) {
			// 2.1 将堆顶元素与末尾元素进行交换
			swap(arrs, 0, i);
			// 2.2 重新对堆进行调整
			adjustHeap(arrs, 0, i);
		}
	} // heapSort
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• adjustHeap

	/**
	 * 调整堆
	 * 
	 * @param arrs
	 * @param index
	 * @param length
	 */
	private void adjustHeap(int[] arrs, int index, int length) {
		
		// 1. 大堆顶，根节点是最大的
		int root = arrs[index];
		
		// 2. 构造大堆顶
		for(int i=2*index+1; i<length; i=i*2+1) {
			
			// 2.1 左右节点比较
			if(arrs[i] < arrs[i+1] && (i+1)<length) {
				i++;
			}
			
			// 2.2 父子节点比较
			if(arrs[i] > root) {
				arrs[index] = arrs[i];
				index = i;
			} else {
				break;
			}
		} // end for
		
		// 3. 把根节点放在该到的位置
		arrs[index] = root;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 输出样例

堆排序:
-99 -1 0 1 5 11 15 20 100 
1
2