文章目录
1 堆的定义
堆是计算机科学中一类特殊的数据结构的统称,堆通常可以被看做是一棵完全二叉树的数组对象。
堆的特性:
- 它是完全二叉树: 除了树的最后一层结点不需要是满的,其它的每一层从左到右都是满的,如果最后一层结点不是满的,那么要求左满右不满。
- 它通常用数组来实现:具体方法就是将二叉树的结点按照层级顺序放入数组中,根结点在位置1,它的子结点在位置2和3,而子结点的子结点则分别在位置4,5,6和7,以此类推。
如果一个结点的位置为k,则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样,在不使用指针的情况下,我们也可以通过计算数组的索引在树中上下移动:从a[k]向上一层,就令k等于k/2,向下一层就令k等于2k或2k+1。
- 每个结点都大于等于它的两个子结点: 这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点,但这两个子结点的顺序并没有做规定,跟我们之前学习的二叉查找树是有区别的。
2 堆的API设计
3 堆的实现
3.1 insert插入方法的实现
堆是用数组完成数据元素的存储的,由于数组的底层是一串连续的内存地址,所以我们要往堆中插入数据,我们只能往数组中从索引0处开始,依次往后存放数据,但是堆中对元素的顺序是有要求的,每一个结点的数据要大于等于它的两个子结点的数据,所以每次插入一个元素,都会使得堆中的数据顺序变乱,这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。
所以,如果往堆中新插入元素,我们只需要不断的比较新结点a[k]和它的父结点a[k/2]的大小,然后根据结果完成数据元素的交换,就可以完成堆的有序调整。
3.2 delMax删除最大元素方法的实现
由堆的特性我们可以知道,索引1处的元素,也就是根结点就是最大的元素,当我们把根结点的元素删除后,需要有一个新的根结点出现,这时我们可以暂时把堆中最后一个元素放到索引1处,充当根结点,但是它有可能不满足堆的有序性需求,这个时候我们就需要通过一些方法,让这个新的根结点放入到合适的位置。
3.3 堆的实现代码
/**
* 堆的实现
*/
public class Heap<T extends Comparable> {
//存储数据数组
private T[] items;
//数组大小
private int N;
//构造函数初始化参数
public Heap(int capacity) {
items = (T[]) new Comparable[capacity + 1];
this.N = 0;
}
//插入元素,在最后插入一个元素,然后上浮
public void insert(T t) {
items[++N] = t;
swim(N);
}
//上浮算法
public void swim(int k) {
//通过循环,不断的比较当前结点的值和其父结点的值,如果发现父结点
// 的值比当前结点的值小,则交换位置
while (k > 1) {
//比较k和其父节点的大小
if (less(k / 2, k)) {
exch(k / 2, k);
}
//变换k大小
k = k / 2;
}
}
public T delMax() {
T t = items[1];
//交换索引1处的元素和最大索引处的元素,
// 让完全二叉树中最右侧的元素变为临时根结点
exch(1, N);
//删除最后一个元素
items[N] = null;
N--;
//下沉方法,调整顺序
sink(1);
return t;
}
public void sink(int k) {
//通过循环不断的对比当前k结点和其左子结点2*k以及右子结点2k+1处中的较大值的元素大小,如果当前结点小,则需要交换位置
while (2 * k <= N) {
//先找到左子树和右子树中最小值的索引
int max = 0;
//如果有右节点
if (2 * k + 1 <= N) {
if (less(2 * k + 1, 2 * k)) {
max = 2 * k;
} else {
max = 2 * k + 1;
}
} else {
max = 2 * k;
}
//比较当前结点和较大结点的值
if (!less(k, max)) {
break;
}
//交换k索引处的值和max索引处的值
exch(k, max);
//变换k的值
k = max;
}
}
//比较索引a和索引b中元素大小
public boolean less(int a, int b) {
return items[a].compareTo(items[b]) < 0;
}
//交换索引a和索引b处元素位置
public void exch(int a, int b) {
T temp = items[a];
items[a] = items[b];
items[b] = temp;
}
public static void main(String[] args) {
Heap<String> heap = new Heap<>(6);
heap.insert("A");
heap.insert("C");
heap.insert("B");
heap.insert("D");
heap.insert("F");
heap.insert("E");
String result = null;
while ((result = heap.delMax()) != null) {
System.out.println(result);
}
}
}
4 堆排序
给定一个数组: String[] arr = {“S”,“O”,“R”,“T”,“E”,“X”,“A”,“M”,“P”,“L”,“E”}
请对数组中的字符按从小到大排序。
实现步骤:
- 构造堆;
- 得到堆顶元素,这个值就是最大值;
- 交换堆顶元素和数组中的最后一个元素,此时所有元素中的最大元素已经放到合适的位置;
- 对堆进行调整,重新让除了最后一个元素的剩余元素中的最大值放到堆顶;
- 重复2~4这个步骤,直到堆中剩一个元素为止。
API设计
4.1 堆构造过程
堆的构造,最直观的想法就是另外再创建一个和新数组数组,然后从左往右遍历原数组,每得到一个元素后,添加到新数组中,并通过上浮,对堆进行调整,最后新的数组就是一个堆。
上述的方式虽然很直观,也很简单,但是我们可以用更聪明一点的办法完成它。创建一个新数组,把原数组0~length-1 的数据拷贝到新数组的1~length处,再从新数组长度的一半处(因为叶子节点没有子节点)开始往1索引处扫描(从右往左),然后对扫描到的每一个元素做下沉调整即可。
4.2 堆排序过程
对构造好的堆,我们只需要做类似于堆的删除操作,就可以完成排序。
- 将堆顶元素和堆中最后一个元素交换位置;
- 通过对堆顶元素下沉调整堆,把最大的元素放到堆顶(此时最后一个元素不参与堆的调整,因为最大的数据已经到了数组的最右边)
- 重复1~2步骤,直到堆中剩最后一个元素。
4.3 代码实现
import java.util.Arrays;
/**
* 堆排序
*/
public class HeapSort {
//判断heap堆中索引i处的元素是否小于索引j处的元素
private static boolean less(Comparable[] heap, int i, int j) {
return heap[i].compareTo(heap[j]) < 0;
}
//交换heap堆中i索引和j索引处的值
private static void exch(Comparable[] heap, int i, int j) {
Comparable tmp = heap[i];
heap[i] = heap[j];
heap[j] = tmp;
}
//根据原数组source,构造出堆heap
private static void createHeap(Comparable[] source, Comparable[] heap) {
//把source中的元素拷贝到heap中,heap中的元素就形成一个无序的堆
System.arraycopy(source, 0, heap, 1, source.length);
//对堆中的元素做下沉调整(从长度的一半处开始,往索引1处扫描)
for (int i = (heap.length) / 2; i > 0; i--) {
sink(heap, i, heap.length - 1);
}
}
//对source数组中的数据从小到大排序
public static void sort(Comparable[] source) {
//构建堆
Comparable[] heap = new Comparable[source.length + 1];
createHeap(source, heap);
//定义一个变量,记录未排序的元素中最大的索引
int N = heap.length - 1;
//通过循环,交换1索引处的元素和排序的元素中最大的索引处的元素
while (N != 1) {
//交换元素
exch(heap, 1, N);
//排序交换后最大元素所在的索引,让它不要参与堆的下沉调整
N--;
//需要对索引1处的元素进行对的下沉调整
sink(heap, 1, N);
}
//把heap中的数据复制到原数组source中
System.arraycopy(heap, 1, source, 0, source.length);
}
//在heap堆中,对target处的元素做下沉,范围是0~range
private static void sink(Comparable[] heap, int target, int range) {
while (2 * target <= range) {
//1.找出当前结点的较大的子结点
int max;
if (2 * target + 1 <= range) {
if (less(heap, 2 * target, 2 * target + 1)) {
max = 2 * target + 1;
} else {
max = 2 * target;
}
} else {
max = 2 * target;
}
//2.比较当前结点的值和较大子结点的值
if (!less(heap, target, max)) {
break;
}
exch(heap, target, max);
target = max;
}
}
public static void main(String[] args) {
//待排序数组
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
//通过HeapSort对数组中的元素进行排序
sort(arr);
//打印排序后数组中的元素
System.out.println(Arrays.toString(arr));
}
}