目录
一、堆
1.1 堆的定义
堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。
堆的特性：
-
它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。
-
它通常用数组来实现。
具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置 1 ，它的子结点在位置 2 和 3 ，而子结点的子结点则分别在位置4,5,6和 7 ，以此类推。
如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。 -
每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。
1.2 堆的API设计
| 类名 | Heap <T extends Comparable> |
|---|---|
| 构造方法 | Heap(int capacity)：创建容量为capacity的Heap对象 |
| 成员方法 | 1. private boolean less(int i,int j)：判断堆中索引i处的元素是否小于索引j处的元素
2.private void exch(int i,int j):交换堆中i索引和j索引处的值 3.public T delMax():删除堆中最大的元素,并返回这个最大元素 4.public void insert(T t)：往堆中插入一个元素 5.private void swim(int k):使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置 6.private void sink(int k):使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置 |
| 成员变量 | 1. private T[] imtes : 用来存储元素的数组
2. private int N：记录堆中元素的个数 |
1.3 堆的实现
1.3.1、 insert插入方法的实现
堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只能往数组中从索引 0 处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。
以字母表顺序为例：
所以，如果往堆中新插入元素，我们只需要不断的比较新结点a[k]和它的父结点a[k/2]的大小，然后根据结果完成数据元素的交换，就可以完成堆的有序调整。
1.3.2、 delMax删除最大元素方法的实现
由堆的特性我们可以知道，索引 1 处的元素，也就是根结点就是最大的元素，当我们把根结点的元素删除后，需要有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引 1 处，充当根结点，但是它有可能不满足堆的有序性需求，这个时候我们就需要通过一些方法，让这个新的根结点放入到合适的位置。
所以，当删除掉最大元素后，只需要将最后一个元素放到索引 1 处，并不断的拿着当前结点a[k]与它的子结点a[2k]和a[2k+1]中的较大者交换位置，即可完成堆的有序调整。
1.3.3、 堆的实现代码
public class Heap<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数，也即N为最大索引
private int N;
public Heap(int capacity) {
this.items= (T[]) new Comparable[capacity+1];
this.N=0;
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i,int j){
return items[i].compareTo(items[j])<0;
}
//交换堆中i索引和j索引处的值
private void exch(int i,int j){
T temp = items[i];
items[i] = items[j];
items[j] = temp;
}
//往堆中插入一个元素
public void insert(T t){
items[++N]=t; //想明白++N的意义
swim(N);
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k){
//通过循环，不断的比较当前结点的值和其父结点的值，如果发现父结点的值比当前结点的值小，则交换位置
while(k>1){ // k>1的原因在于由k来上下移动
//比较当前结点(k)和其父结点(k/2)
if (less(k/2,k)){
exch(k/2,k); // 交换位置
}
k = k/2;
}
}
//删除堆中最大的元素,并返回这个最大元素，即根结点
public T delMax(){
T max = items[1];
//交换索引1处的元素和最大索引处的元素，让完全二叉树中最右侧的元素变为临时根结点
exch(1,N);
//最大索引处的元素删除掉
items[N]=null;
//元素个数-1
N--;
//通过下沉调整堆，让堆重新有序
sink(1);
return max;
}
//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k){
//通过循环不断的对比当前k结点和其左子结点2*k以及右子结点2k+1处中的较大值的元素大小，如果当前结点小，则需要交换位置
while(2*k<=N){ //保证有左子结点
//获取当前结点的子结点中的较大结点
int max; //记录较大结点所在的索引
if (2*k+1<=N){
if (less(2*k,2*k+1)){
max=2*k+1;
}else{
max=2*k;
}
}else {
max = 2*k;
}
//比较当前结点和较大结点的值
if (!less(k,max)){
break;
}
//交换k索引处的值和max索引处的值，使该结点下沉
exch(k,max);
//变换k的值
k = max;
}
}
//测试类
public class HeapTest {
public static void main(String[] args) {
//创建堆对象
Heap<String> heap = new Heap<>(10);
//往堆中存入字符串数据
heap.insert("A");
heap.insert("B");
heap.insert("C");
heap.insert("D");
heap.insert("E");
heap.insert("F");
heap.insert("G");
//通过循环从堆中删除数据
String result = null;
while((result = heap.delMax())!=null){
System.out.print(result+" ");
}
}
}
1.4 堆排序
给定一个数组：
String[ ] arr = {“S”,“O”,“R”,“T”,“E”,“X”,“A”,“M”,“P”,“L”,“E”}
请对数组中的字符按从小到大排序。
API设计：
| 类名 | HeapSort<T extends Comparable<T>> |
|---|---|
| 成员方法 | 1.public static void sort(Comparable[] source)：对source数组中的数据从小到大排序
2.private static void createHeap(Comparable[] source, Comparable[] heap):根据原数组source，构造出对应的 堆heap 3.private static boolean less(Comparable[] heap, int i, int j)：判断heap堆中索引i处的元素是否小于索引j处的元素 4.private static void exch(Comparable[] heap, int i, int j):交换heap堆中i索引和j索引处的值 5.private static void sink(Comparable[] heap, int target, int range):在heap堆中，对target处的元素做下沉，范围是0~range。 |
实现步骤：
- 构造堆；
- 得到堆顶元素，这个值就是最大值；
- 交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；
- 对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；
- 重复2~4这个步骤，直到堆中剩一个元素为止。
1.4.1 堆构造过程
堆的构造，最直观的想法就是另外再创建一个新数组，然后从左往右遍历原数组，每得到一个元素后，添加到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。
上述的方式虽然很直观，也很简单，但是我们可以用更聪明一点的办法完成它。创建一个新数组，把原数组0~length-1 的数据拷贝到新数组的1~length处，再从新数组长度的一半处开始往 1 索引处扫描（从右往左），然后对扫描到的每一个元素做下沉调整即可。
1.4.2 堆排序过程
对构造好的堆，我们只需要做类似于堆的删除操作，就可以完成排序。
- 将堆顶元素和堆中最后一个元素交换位置；
- 通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到了数组的最右边)
- 重复1~2步骤，直到堆中剩最后一个元素。
代码：
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) {
//构建堆
//长度加1的原因就是，会把堆所对应的数组的0索引处的元素废弃掉，如果还要存储跟原数组长度相同的元素的话，需要往上加1
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 class HeapSortTest {
public static void main(String[] args) {
//待排序数组
String[] arr = {"S","O","R","T","E","X","A","M","P","L","E"};
//通过HeapSort对数组中的元素进行排序
HeapSort.sort(arr);
//打印排序后数组中的元素
System.out.println(Arrays.toString(arr));
}
}
941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
