算法——排序之堆排序
2017-05-17 15:51
357 查看
堆排序是一种基于堆的排序。要了解堆排序,首先我们要了解堆的特性。
那么什么是堆呢?
这里我们使用大顶堆,并且是二叉堆,且用数组实现的方式作为例子。
在二叉堆的数组中,每个元素都要保证大于等于两个特定位置的元素,这里所说的特定位置,在树结构中就是它的子节点。所有节点都要满足上面所说的情况。如果我们画成二叉树的形式,我们就很容易理解了。
可以看到,如果满足上面的特点的话,那么树的根节点的元素的值一直是最大的,这就是大顶堆。同样的也有小顶堆,根节点的元素是最小的。
而对于数组实现的二叉堆来说,他们的父子关系非常容易确认。我们设数组中a[1]为根节点。那么他的子节点就是2,3。对于某个节点k呢?他的子节点就是2*k和2*k+1。父节点就是k/2。当然这需要我们将数组a[1]作为根节点,而不是用a[0]。用a[0]也可以,但是父子节点关系没这么简单而已,不过也差不了多少。习惯上用a[1]作为根节点。我们这里也采用这种方式。
看到这个结构,有没有对使用堆结构的排序有一种恍然大悟的想法呢?
对,我们可以使用堆结构来优化我们的选择排序。因为选择排序每一轮就是找到最大的元素,然后固定位置。而堆结构能够非常快速的给我们他的最大值。这样,他一直给我们提供最大值的话,我们就可以轻而易举的完成选择排序了!
不过我们首先要了解的是,如何建立一个堆。还需要了解建立这个堆,以及这个堆给我们提供最大值的效率是多少?如果建立这个堆花费代价很大,并且给我们提供最大值也需要很大的代价的话,上面提到的就完全没有意义了。幸运的是,建立堆,并且获取最大值代价并不大。
给我们一个数组,我们怎么样可以使得这个数组是一个二叉堆呢?
我们采用下沉的办法。我们假设原本这个是一个堆结构,但是突然,其中一个元素之改变了,那么我们如何将这个堆结构重新维护起来呢?
如图所示:除了下沉的节点之外,其他的节点已经满足堆结构的要求。
对于叶节点我们不需要管,我们只需要遍历所有不是叶节点的节点,让他们下沉。因为我们认为只有叶节点,已经是一个堆结构了。这样,从后向前,因为后面的永远是一个堆结构,每次我们只对一个元素进行定位,也就是下沉,就能够将堆建立起来。
这样,当我们下沉完毕的时候,这个堆就创建好了。
堆我们已经创建好了,那么我们如何利用他进行排序呢?
我们采用这个思路:每次将最大的元素和数组末尾的元素进行位置的交换。
但是将数组末尾的元素放在根节点上,堆结构就被破坏了。所以我们需要重新维护这个堆。因为我们除了根节点和数组末尾的元素之外,其他地方都已经是一个堆结构了。所以我们可以将交换上来的,新的根节点下沉。当然,这个时候建立堆的数组就应该缩小了,应该将数组末尾的元素剔除,也就是数组的大小减一。这样才能满足除了根节点之外,数组已经是一个堆的这么一个前提。
当我们慢慢的将根节点的元素放到数组的末尾去,因为根节点的元素永远是当前数组中最大的,所以我们就可以从后向前慢慢的排序起来。
如图所示:
代码如下:
当堆已经存在的时候,我们插入一个元素所需时间为O(logN)。我们需要插入N/2个元素。所以堆排序的时间复杂度是O(nlogn)。
而对于空间复杂度,我们以外的发现,堆排序的空间复杂度仅仅为O(1),并且它最坏复杂度也是O(nlogn)。
时间复杂度达到了下限,空间复杂度也是常数级别的。那么是不是意味着堆排序超6,碾压其他算法呢?
但我们的应用一般都不会使用堆排序,用的最多的还是快排,为什么呢?
我们先来比较一下归并排序,快速排序,堆排序的效率:
当数组大小为1000时:
这是由于计算机缓存的原因。因为在堆排序中,数组很少会和相邻的元素进行比较,这对于现代操作系统来说,就不是一个很好的东西了。因为它的缓存命中概率很小。在需要排序的数组很小的时候,可以一次把数组都读到缓存中,这就和快排,归并排序差不多。但是当数组变大的时候,就不能把数组都放到缓存中了,所以效率一下子就低下来了。在这点上,数组大了之后,甚至还比不过希尔排序。快排之所以快,其中一点非常重要的原因就是因为命中率极高。
但这是不是意味着堆排序没卵用呢?
也不是这样的,在没有多少缓存,并且不能给我们提供很大的空间的时候,堆排序就非常有用了。例如在嵌入式系统中,堆排序是重要的排序手段。
而且用堆实现的优先队列在很多应用中都是广为使用的。
那么什么是堆呢?
这里我们使用大顶堆,并且是二叉堆,且用数组实现的方式作为例子。
在二叉堆的数组中,每个元素都要保证大于等于两个特定位置的元素,这里所说的特定位置,在树结构中就是它的子节点。所有节点都要满足上面所说的情况。如果我们画成二叉树的形式,我们就很容易理解了。
可以看到,如果满足上面的特点的话,那么树的根节点的元素的值一直是最大的,这就是大顶堆。同样的也有小顶堆,根节点的元素是最小的。
而对于数组实现的二叉堆来说,他们的父子关系非常容易确认。我们设数组中a[1]为根节点。那么他的子节点就是2,3。对于某个节点k呢?他的子节点就是2*k和2*k+1。父节点就是k/2。当然这需要我们将数组a[1]作为根节点,而不是用a[0]。用a[0]也可以,但是父子节点关系没这么简单而已,不过也差不了多少。习惯上用a[1]作为根节点。我们这里也采用这种方式。
看到这个结构,有没有对使用堆结构的排序有一种恍然大悟的想法呢?
对,我们可以使用堆结构来优化我们的选择排序。因为选择排序每一轮就是找到最大的元素,然后固定位置。而堆结构能够非常快速的给我们他的最大值。这样,他一直给我们提供最大值的话,我们就可以轻而易举的完成选择排序了!
不过我们首先要了解的是,如何建立一个堆。还需要了解建立这个堆,以及这个堆给我们提供最大值的效率是多少?如果建立这个堆花费代价很大,并且给我们提供最大值也需要很大的代价的话,上面提到的就完全没有意义了。幸运的是,建立堆,并且获取最大值代价并不大。
给我们一个数组,我们怎么样可以使得这个数组是一个二叉堆呢?
我们采用下沉的办法。我们假设原本这个是一个堆结构,但是突然,其中一个元素之改变了,那么我们如何将这个堆结构重新维护起来呢?
如图所示:除了下沉的节点之外,其他的节点已经满足堆结构的要求。
对于叶节点我们不需要管,我们只需要遍历所有不是叶节点的节点,让他们下沉。因为我们认为只有叶节点,已经是一个堆结构了。这样,从后向前,因为后面的永远是一个堆结构,每次我们只对一个元素进行定位,也就是下沉,就能够将堆建立起来。
这样,当我们下沉完毕的时候,这个堆就创建好了。
堆我们已经创建好了,那么我们如何利用他进行排序呢?
我们采用这个思路:每次将最大的元素和数组末尾的元素进行位置的交换。
但是将数组末尾的元素放在根节点上,堆结构就被破坏了。所以我们需要重新维护这个堆。因为我们除了根节点和数组末尾的元素之外,其他地方都已经是一个堆结构了。所以我们可以将交换上来的,新的根节点下沉。当然,这个时候建立堆的数组就应该缩小了,应该将数组末尾的元素剔除,也就是数组的大小减一。这样才能满足除了根节点之外,数组已经是一个堆的这么一个前提。
当我们慢慢的将根节点的元素放到数组的末尾去,因为根节点的元素永远是当前数组中最大的,所以我们就可以从后向前慢慢的排序起来。
如图所示:
代码如下:
public static void sort(Comparable[] a) { // 先构造堆 int N = a.length; for (int i = N / 2; i >= 1; i--) { sink(a, i, N); } // 排序,销毁堆 while (N-- > 1) { swap(a, 1, N); sink(a, 1, N); } } public static void sink(Comparable[] a, int begin, int length) { while (begin * 2 < length) { int maxIndex = begin * 2; if (maxIndex + 1 < length && less(a[maxIndex], a[maxIndex + 1])) { // 如果有两个子节点,选择较大的子节点 maxIndex++; } if (!less(a[begin], a[maxIndex])) break; swap(a, begin, maxIndex); begin = maxIndex; } }
当堆已经存在的时候,我们插入一个元素所需时间为O(logN)。我们需要插入N/2个元素。所以堆排序的时间复杂度是O(nlogn)。
而对于空间复杂度,我们以外的发现,堆排序的空间复杂度仅仅为O(1),并且它最坏复杂度也是O(nlogn)。
时间复杂度达到了下限,空间复杂度也是常数级别的。那么是不是意味着堆排序超6,碾压其他算法呢?
但我们的应用一般都不会使用堆排序,用的最多的还是快排,为什么呢?
我们先来比较一下归并排序,快速排序,堆排序的效率:
public static void main(String[] args) { final int NUM = 1000000; Integer[] a1 = new Integer[NUM]; Integer[] a2 = new Integer[NUM]; Integer[] a3 = new Integer[NUM]; Integer[] a4 = new Integer[NUM]; a1[0] = a2[0] = a3[0] = a4[0] = -1; for (int i = 1; i < NUM; i++) { a1[i] = (int) (Math.random() * NUM); a2[i] = a1[i]; a3[i] = a1[i]; a4[i] = a1[i]; } long startTime; long endTime; startTime = System.currentTimeMillis(); // 获取开始时间 QuickSort.sort2(a2); assert isSorted(a2); endTime = System.currentTimeMillis(); System.out.println("Quick排序cost: " + (endTime - startTime) + " ms"); startTime = System.currentTimeMillis(); // 获取开始时间 MergeSort.sort2(a3); assert isSorted(a3); endTime = System.currentTimeMillis(); System.out.println("Merge排序cost: " + (endTime - startTime) + " ms"); startTime = System.currentTimeMillis(); // 获取开始时间 HeapSort.sort(a1); assert isSorted(a1); endTime = System.currentTimeMillis(); System.out.println("Heap排序cost: " + (endTime - startTime) + " ms"); }我们改变一下数组大小。
当数组大小为1000时:
Quick排序cost: 4 ms Merge排序cost: 2 ms Heap排序cost: 1 ms数组大小为10000时:
Quick排序cost: 10 ms Merge排序cost: 9 ms Heap排序cost: 10 ms数组大小为100000时:
Quick排序cost: 79 ms Merge排序cost: 85 ms Heap排序cost: 121 ms数组大小为1000000时:
Quick排序cost: 421 ms Merge排序cost: 470 ms Heap排序cost: 929 ms我们发现,当数组越来越大的时候,堆排序的效率就被慢慢拉开了。这是为什么呢?
这是由于计算机缓存的原因。因为在堆排序中,数组很少会和相邻的元素进行比较,这对于现代操作系统来说,就不是一个很好的东西了。因为它的缓存命中概率很小。在需要排序的数组很小的时候,可以一次把数组都读到缓存中,这就和快排,归并排序差不多。但是当数组变大的时候,就不能把数组都放到缓存中了,所以效率一下子就低下来了。在这点上,数组大了之后,甚至还比不过希尔排序。快排之所以快,其中一点非常重要的原因就是因为命中率极高。
但这是不是意味着堆排序没卵用呢?
也不是这样的,在没有多少缓存,并且不能给我们提供很大的空间的时候,堆排序就非常有用了。例如在嵌入式系统中,堆排序是重要的排序手段。
而且用堆实现的优先队列在很多应用中都是广为使用的。
相关文章推荐
- 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法,而冒泡排序、插入排序、归并排序和基数排序
- 重新教自己学算法之递归排序——堆排序(六)
- 【数据结构与算法】【排序】堆排序的代码实现
- 基础算法(二):堆排序,快速排序
- 【算法拾遗(java描写叙述)】--- 选择排序(直接选择排序、堆排序)
- Python 快速排序 堆排序——Python实现一些算法持续更新
- 10种算法原理(冒泡排序,选择排序,快速排序,堆排序,希尔排序,桶排序等)
- 常用排序算法之——堆排序
- 【数据结构和算法】排序算法之二:选择排序和堆排序
- Java实现排序算法之堆排序
- 算法初级02——荷兰国旗问题、随机快速排序、堆排序、桶排序、相邻两数的最大差值问题、工程中的综合排序算法
- 算法基础之排序篇-堆排序
- 算法 ----- 排序NB二人组 堆排序 归并排序
- 算法学习记录-排序——堆排序
- <菜鸟学算法-A排序(分治的思想:堆排序)>
- 10种算法原理(冒泡排序,选择排序,快速排序,堆排序,希尔排序,桶排序等)
- 基于JAVA的排序算法之七--堆排序
- 【数据结构和算法】排序算法之二:选择排序和堆排序
- 算法有插入排序,堆排序,合并排序,快速排序和stooge排序
- 第十五周项目1 验证算法(5)选择排序之堆排序