堆
堆的定义
堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。
从定义上来看堆也是一种树但是必须是完全二叉树，完全二叉树定义：
是一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。
我们看如下图所示：左边的是一个完全二叉树，右边的不是，如何判断是不是一棵完全二叉树我们看下面堆的性质1
堆的特性：
1.它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不是满的，那么要求左满右不满。
2.它通常用数组来实现。
具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子结点则分别在位置4,5,6和7，以此类推。0索引处不存数据因为将数据从第一个开始存储方便我们表示父节点和子节点的关系
如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。
3.每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个子结点的顺序并没有做规定，这一点与二叉查找树是有区别的。
堆的实现
API设计
insert插入方法的实现
堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只能往数组中从索引0处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些方法让刚才插入的这个数据放入到合适的位置。那么该方法便是swim方法使索引k处的元素能在堆中处于一个正确的位置。我们来看一个向堆中插入元素的上浮过程。
初始堆如下
此时要插入一个元素S那么该如何插入呢？为了满足堆的性质我们只能在H的右结点处插入
插入S后我们发现S比他的父节点H要大所以我们需要交换S和H的位置
S继续和其父节点P进行比较S比P大则继续交换得到如下所示
此时S比其父节点T要小故不用交换，所以便完成了元素的插入。因此，如果要往堆中新插入元素，我们只需要不断的比较新结点a[k]和它的父结点a[k/2]的大小，然后根据结果完成数据元素的交换，就可以完成堆的有序调整。
将上诉过程转换为代码如下：
//往堆中插入一个元素
public void insert(T t){
//因为我们是从索引为1的位置开始存数据故先++N
items[++N]=t;
swim(N);
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k){
//通过循环，不断的比较当前结点的值和其父结点的值，
//如果发现父结点的值比当前结点的值小，则交换位置
while(k>1){
//比较当前结点和其父结点
if (less(k/2,k)){
exch(k/2,k);
}
k = k/2;
}
}
delMax删除最大元素方法的实现
由堆的特性我们可以知道，索引1处的元素，也就是根结点就是最大的元素，当我们把根结点的元素删除后，需要有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引1处，充当根结点，但是它有可能不满足堆的有序性需求，这个时候我们就需要使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置，让这个新的根结点放入到合适的位置。
初始堆如下：
删除最大元素T，最大元素即为根结点，删除了根元素之后那么树便成了左右两棵树即变成了森林，所以删除掉根元素后我们需要找一个元素来替换根元素。可能我们一开始想到的是其子节点，其实是不妥的因为左右节点不知道哪个大，而且交换后树的结构更乱了。因此我们可以把根结点与最后一个结点交换。交换后再把根结点删除，删除后此时的堆也是无序的。
我们需要对堆做出调整，我们只需要找出原来结点的左右子结点中最大的然后与当前结点比较如果当前节点比他大则位置不需要变化，如果要小则最大的结点与当前结点交换。
GS交换后此时仍然需要继续比较G与其子结点的大小继续比较。
所以，当删除掉最大元素后，只需要将最后一个元素放到索引1处，并不断的拿着当前结点a[k]与它的子结点a[2k]和a[2k+1]中的较大者交换位置，即可完成堆的有序调整。
代码实现如下
//删除堆中最大的元素,并返回这个最大元素
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 Heap<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
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;
swim(N);
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k){
//通过循环，不断的比较当前结点的值和其父结点的值，
//如果发现父结点的值比当前结点的值小，则交换位置
while(k>1){
//比较当前结点和其父结点
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 static void main(String[] args) {
Heap<String> heap = new Heap<String>(20);
heap.insert("A");
heap.insert("B");
heap.insert("C");
heap.insert("D");
heap.insert("E");
heap.insert("F");
heap.insert("G");
String del;
while((del=heap.delMax())!=null){
System.out.print(del+",");
}
}
测试结果：
G,F,E,D,C,B,A,
堆排序
问题引入
给定一个数组：
String[] arr = {“S”,“O”,“R”,“T”,“E”,“X”,“A”,“M”,“P”,“L”,“E”}
请对数组中的字符按从小到大排序。
实现步骤：
- 构造堆；
- 得到堆顶元素，这个值就是最大值；
- 交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；
- 对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；
- 重复2~4这个步骤，直到堆中剩一个元素为止。
堆构建过程
堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。
上述的方式虽然很直观，也很简单，但是我们可以用更巧妙一点的办法完成它。创建一个新数组，把原数组0-length-1的数据拷贝到新数组的1~length处，再从新数组长度的一半处开始往1索引处扫描（从右往左）（因为堆的性质是知道一个节点便可以知道其两个子节点），然后对扫描到的每一个元素做下沉调整即可。具体看下面图解
从新数组长度的一半处开始往1索引处扫描，即从5处开始扫描L比E大交换位置
索引4处T比其子节点MP都大故不需要移动
索引3处R比其两个子节点大也不需要移动
索引2处T比其两个子节点大也不需要移动
索引1处X比其两个子节点大也不需要移动
经过5次比较后堆便构建好了我们用代码将该过程实现
//根据原数组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);
}
}
//在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;
}
}
堆排序过程
- 将堆顶元素和堆中最后一个元素交换位置；
- 通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到了数组的最右边)
- 重复1~2步骤，直到堆中剩最后一个元素。
经过上面的操作后数组已经有序了。我们用代码将其实现。
//对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);
}
堆排序完整代码
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 class TestHeapSort {
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));
}
}
测试结果：
[A, E, E, L, M, O, P, R, S, T, X]
扫一扫
24万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
