第六章：堆排序

一、堆的基本概念

一般我们讲的堆都是二叉堆。

二叉堆简单地来说就是一个完全二叉树。

完全二叉树：从左到右、从上到下塞满的一颗二叉树。

满二叉树：每层都塞满的二叉树。

堆分为大根堆（每个父亲都比儿子大，其中根为最大的元素）、小根堆（每个父亲都比儿子小，其中根为最小的元素）。

某个节点的高度为从该节点到叶子节点经过的路径的长度，比如叶子节点的高度为0。

d叉堆：一个父亲有d个孩子的完全d叉树。

最大堆应用于

(1)进程调度、任务调度，每次提取一个优先级最高的进程或任务。

(2)优先级队列，每次提取一个优先级最高的元素，并且始终维持着优先级。

二、二叉堆的性质

1.给定一个节点的索引为i，则

        父亲节点为floor(i/2)，也可以i>>1来实现。

        左孩子节点为2*i，也可以用i<<1实现。

        右孩子节点索引为 2*i+1，也可以用(i<<1)+1。

一般来说这些函数都是用“宏”或“内联函数”来实现，在C++中inline，而在Java中用final实现。

2.给定一个节点，他为根的树的节点数目为n，则左子树最多有2n/3个节点。

 

3.在n个元素的堆中，叶子节点有ceil(n/2)个节点，其余有floor(n/2)。

4.在n个元素的堆中，高度为h至多有

各节点。

5.floor(n/2)+1，floor(n/2)+2，.....，n都是叶子节点。

6.高度为floor(logn)。

三、d叉堆的性质

其实二叉堆的一系列性质也是由d叉堆推出的。

 

三、d叉堆的实现

二叉堆的实现就不给出了，直接给出d叉最小堆和d叉最大堆的实现。

1.最小堆

import java.util.Arrays;/** * d叉最小堆 * @author xiazdong * */public class D_MIN_HEAP {private static int MAX = Integer.MAX_VALUE;private int arr[];private int d;//d叉堆private int heap_size;//目前堆的大小private int MEMORY_SIZE;//能够存储的总数组大小public static void main(String[] args) {D_MIN_HEAP heap = new D_MIN_HEAP(2);for(int i=0;i<10;i++){heap.insert(i);}heap.print();heap.delete(1);heap.print();}/** * 按层输出堆 */public void print() {int height = height();for(int h=0;h<=height;h++){System.out.print("第"+h+"层:");int begin = (int)((Math.pow(d, h)-1)/(d-1)+1);int end = (int)((Math.pow(d, h+1)-1)/(d-1));for(int j=begin;j<=heap_size&&j<=end;j++){System.out.print(arr[j]+" ");}System.out.println();}}/** *  * @param d d叉堆 */public D_MIN_HEAP(int d){this.d = d;heap_size = 0;MEMORY_SIZE = 1024;arr = new int[MEMORY_SIZE];}/** * 返回堆的高度 * @return */public int height(){return (int)(log(heap_size, d)+log(d-1, d));}/** * 返回x的父亲节点的索引 * @param x * @return */public final int parent(int x){return (x + d - 2)/d;}/** * 将第i个位置的内容删去 * @param i * @return */public void delete(int i){arr[i] = arr[heap_size];heap_size--;MIN_HEAPIFY(i);}/** * 插入一个元素，并维持最大堆 * @param k */public void insert(int k){heap_size++;arr[heap_size] = MAX;ensureCapacity(heap_size+1);DECREASE_KEY(heap_size,k);}//参考ArrayList实现private void ensureCapacity(int x){if(x>=(int)(MEMORY_SIZE)){//自增长数组MEMORY_SIZE = MEMORY_SIZE * 2;arr = Arrays.copyOf(arr, MEMORY_SIZE);//newarr = Arrays.copyOf(oldarr,newlength);//表示将oldarr的全部内容复制到newarr中，newarr的长度为newlength}}/** * 将arr[x]=k * @param x * @param k */public void DECREASE_KEY(int x, int k) {arr[x] = k;if(arr[x]<k){System.err.println("不需要DECREASE");return;}else{while(x>1&&arr[parent(x)]>arr[x]){swap(parent(x),x);x = parent(x);}}}/** * 返回parent的第number个孩子的节点 * @param parent * @param number * @return */public final int child(int parent,int number){return d * parent - d + 1 + number;}/** * 提取最大元素，并维持最大堆 * @return */public int EXTRACT_MIN(){int MIN = arr[1];arr[1] = arr[heap_size];MIN_HEAPIFY(1);return MIN;}private void MIN_HEAPIFY(int x){int smallest = x;for(int i=1;child(x, i)<=heap_size&&i<=d;i++){if(arr[child(x, i)]<arr[smallest]){smallest = child(x,i);}}if(smallest!=x){swap(smallest,x);MIN_HEAPIFY(smallest);}}/** * 给出另一种交换的程序 * @param smallest * @param x */private void swap(int smallest, int x) {arr[smallest] = arr[smallest]^arr[x];arr[x] = arr[smallest]^arr[x];arr[smallest] = arr[smallest]^arr[x];}private final double log(double value, double base) {return Math.log(value) / Math.log(base);}}

2.最大堆

import java.util.Arrays;/** * d叉最大堆 * @author xiazdong * */public class D_MAX_HEAP {private static int MIN = Integer.MIN_VALUE;private int arr[];private int d;//d叉堆private int heap_size;//目前堆的大小private int MEMORY_SIZE;//能够存储的总数组大小public static void main(String[] args) {D_MAX_HEAP heap = new D_MAX_HEAP(2);for(int i=10;i>0;i--){heap.insert(i);}heap.print();heap.delete(1);heap.print();}/** * 按层输出堆 */public void print() {int height = height();for(int h=0;h<=height;h++){System.out.print("第"+h+"层:");int begin = (int)((Math.pow(d, h)-1)/(d-1)+1);int end = (int)((Math.pow(d, h+1)-1)/(d-1));for(int j=begin;j<=heap_size&&j<=end;j++){System.out.print(arr[j]+" ");}System.out.println();}}/** *  * @param d d叉最大堆 */public D_MAX_HEAP(int d){this.d = d;heap_size = 0;MEMORY_SIZE = 1024;arr = new int[MEMORY_SIZE];}/** * 返回堆的高度 * @return */public int height(){return (int)(log(heap_size, d)+log(d-1, d));}/** * 返回x的父亲节点的索引 * @param x * @return */private final int parent(int x){return (x + d - 2)/d;}/** * 将第i个位置的内容删去 * @param i * @return */public void delete(int i){arr[i] = arr[heap_size];heap_size--;MAX_HEAPIFY(i);}/** * 插入一个元素，并维持最大堆 * @param k */public void insert(int k){heap_size++;arr[heap_size] = MIN;ensureCapacity(heap_size+1);INCREASE_KEY(heap_size,k);}//参考ArrayList实现private void ensureCapacity(int x){if(x>=(int)(MEMORY_SIZE)){//自增长数组MEMORY_SIZE = MEMORY_SIZE * 2;arr = Arrays.copyOf(arr, MEMORY_SIZE);//newarr = Arrays.copyOf(oldarr,newlength);//表示将oldarr的全部内容复制到newarr中，newarr的长度为newlength}}/** * 将arr[x]=k * @param x * @param k */public void INCREASE_KEY(int x, int k) {arr[x] = k;if(arr[x]>k){System.err.println("不需要INCREASE");return;}else{while(x>1&&arr[parent(x)]<arr[x]){swap(parent(x),x);x = parent(x);}}}/** * 返回parent的第number个孩子的节点 * @param parent * @param number * @return */public final int child(int parent,int number){return d * parent - d + 1 + number;}/** * 提取最大元素，并维持最大堆 * @return */public int EXTRACT_MAX(){int max = arr[1];arr[1] = arr[heap_size];MAX_HEAPIFY(1);return max;}private void MAX_HEAPIFY(int x){int largest = x;for(int i=1;child(x, i)<=heap_size&&i<=d;i++){if(arr[child(x, i)]>arr[largest]){largest = child(x,i);}}if(largest!=x){swap(largest,x);MAX_HEAPIFY(largest);}}private void swap(int largest, int x) {int temp = arr[largest];arr[largest] = arr[x];arr[x] = temp;}public double log(double value, double base) {return Math.log(value) / Math.log(base);}}

五、堆排序概念

1964年Williams发明的，1992年Sedgewick发表了堆排序性能分析 "The analysis of heapsort"。

堆排序是原地(In-place sort)排序。