130. Heapify-堆化(siftup & siftdown版本)

原创 2018年04月14日 23:21:17

Description

给出一个整数数组,堆化操作就是把它变成一个最小堆数组。

对于堆数组A,A[0]是堆的根,并对于每个A[i],A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子。

说明

什么是堆?

  • 堆是一种数据结构,它通常有三种方法:push, pop 和 top。其中,“push”添加新的元素进入堆,“pop”删除堆中最小/最大元素,“top”返回堆中最小/最大元素。

什么是堆化?

  • 把一个无序整数数组变成一个堆数组。如果是最小堆,每个元素A[i],我们将得到A[i * 2 + 1] >= A[i]和A[i * 2 + 2] >= A[i]

如果有很多种堆化的结果?

  • 返回其中任何一个。
样例

给出 [3,2,1,4,5],返回[1,2,3,4,5] 或者任何一个合法的堆数组

挑战 

O(n)的时间复杂度完成堆化

Solution

基于 Siftup 的版本 O(nlogn)O(nlogn)

算法思路:

  1. 对于每个元素A[i],比较A[i]和它的父亲结点的大小,如果小于父亲结点,则与父亲结点交换。
  2. 交换后再和新的父亲比较,重复上述操作,直至该点的值大于父亲。

时间复杂度分析

  1. 对于每个元素都要遍历一遍,这部分是 O(n)O(n)
  2. 每处理一个元素时,最多需要向根部方向交换 lognlogn 次。

因此总的时间复杂度是 O(nlogn)O(nlogn)

public class Solution {
    /*
     * @param A: Given an integer array
     * @return: nothing
     */
    Version 2: This cost O(nlogn)
    public void heapify(int[] A) {
        // write your code here
        for (int i = 0; i < A.length; i++) {
            siftup(A, i);
        }
    }
    private void siftup(int[] A, int k) {
        while (k != 0) {
            int father = (k - 1) / 2;
            if (A[k] > A[father]) {
                break;
            }
            int temp = A[k];
            A[k] = A[father];
            A[father] = temp;
            
            k = father;
        }
    }
    
}

基于 Siftdown 的版本 O(n)O(n)

算法思路:

  1. 初始选择最接近叶子的一个父结点,与其两个儿子中较小的一个比较,若大于儿子,则与儿子交换。
  2. 交换后再与新的儿子比较并交换,直至没有儿子。
  3. 再选择较浅深度的父亲结点,重复上述步骤。

时间复杂度分析

这个版本的算法,乍一看也是 O(nlogn)O(nlogn), 但是我们仔细分析一下,算法从第 n/2 个数开始,倒过来进行 siftdown。也就是说,相当于从 heap 的倒数第二层开始进行 siftdown 操作,倒数第二层的节点大约有 n/4 个, 这 n/4 个数,最多 siftdown 1次就到底了,所以这一层的时间复杂度耗费是 O(n/4)O(n/4),然后倒数第三层差不多 n/8 个点,最多 siftdown 2次就到底了。所以这里的耗费是 O(n/8 * 2), 倒数第4层是 O(n/16 * 3),倒数第5层是 O(n/32 * 4) ... 因此累加所有的时间复杂度耗费为:

T(n) = O(n/4) + O(n/8 * 2) + O(n/16 * 3) ...

然后我们用 2T - T 得到:

2 * T(n) = O(n/2) + O(n/4 * 2) + O(n/8 * 3) + O(n/16 * 4) ... 
T(n)     =          O(n/4)     + O(n/8 * 2) + O(n/16 * 3) ...

2 * T(n) - T(n) = O(n/2) +O (n/4) + O(n/8) + ...
                = O(n/2 + n/4 + n/8 + ... )
                = O(n)

因此得到 T(n) = 2 * T(n) - T(n) = O(n)

public class Solution {
    /*
     * @param A: Given an integer array
     * @return: nothing
     */
    // Version 1: this cost O(n)
    public void heapify(int[] A) {
        for (int i = (A.length - 1) / 2; i >= 0; i--) {
            siftdown(A, i);
        }
    }
    private void siftdown(int[] A, int k) {
        while (k * 2 + 1 < A.length) {
            int son = k * 2 + 1;        // A[i] 的左儿子下标
            if (k * 2 + 2 < A.length && A[son] > A[k * 2 + 2]) {
                son = k * 2 + 2;        // 选择两个儿子中较小的
            }
            if (A[son] > A[k]) {
                break;
            }
            int temp = A[son];
            A[son] = A[k];
            A[k] = temp;
            
            k = son;
        }
    }
}


版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/lighthear/article/details/79945528

最大堆/最小堆、siftup和siftdown

从数据的存储结构看,最大堆/最小堆是一个数组。 从数据的逻辑结构看,最大堆/最小堆是一棵完全二叉树。 堆有以下三种基本操作: 1.初始化:将一个无序的序列初始化成堆。从最后一个非叶子结点开始,自右...
  • mach7
  • mach7
  • 2014-02-26 16:48:50
  • 3256

[BCZ-HEAP]堆排序的实现,包括建堆,siftup(主要用于建堆)和siftdown(主要用于调整)函数的实现

堆排序的实现,包括建堆,siftup(主要用于建堆)和siftdown(主要用于调整)函数的实现,注意siftdown函数中的推出循环的条件,别把break落下了/******************...
  • roynee
  • roynee
  • 2009-11-03 16:18:00
  • 2103

lintcode-堆化-130

给出一个整数数组,堆化操作就是把它变成一个最小堆数组。 对于堆数组A,A[0]是堆的根,并对于每个A[i],A [i * 2 + 1]是A[i]的左儿子并且A[i * 2 + 2]是A[i]的右儿子。...
  • ljlstart
  • ljlstart
  • 2015-09-19 23:44:35
  • 619

二叉堆 SiftDown SiftUp

#include #include #include #include #include #include #include #include #include #include #include #...
  • leonardWang
  • leonardWang
  • 2010-05-03 21:15:00
  • 1501

优先队列(priority queue)

定义优先队列是一种支持以下主要操作的抽象数据结构: Insert(p):添加一个带有优先权p的新元素 ExtractMax():取出具有最大优先权的元素 其他操作: Remove(it):...
  • lym152898
  • lym152898
  • 2016-06-29 18:05:00
  • 457

D堆的实现

实现上一篇博客(http://blog.csdn.net/buleriver/article/details/38469977)说的D堆,如果把mD设置成2,D堆就退化成二叉堆,也就是说,二叉堆是D堆...
  • BuleRiver
  • BuleRiver
  • 2014-08-12 15:14:32
  • 2580

d堆

就是d叉堆,是二叉堆的简单推广(http://blog.csdn.net/buleriver/article/details/38469907) 对于一个d堆,也是可以使用数组表示,关键是如何通过索...
  • BuleRiver
  • BuleRiver
  • 2014-08-10 14:53:18
  • 2299

LintCode 130 [递归]堆化---堆的调整

题目 http://www.lintcode.com/zh-cn/problem/heapify/ 给出一个整数数组,堆化操作就是把它变成一个最小堆数组。 对于堆数组A,A[0]是堆的根,并对...
  • qq_30138291
  • qq_30138291
  • 2017-07-17 17:39:57
  • 161

*[Lintcode] Heapify 堆化

Given an integer array, heapify it into a min-heap array. For a heap array A, A[0] is the root of...
  • jc69186918
  • jc69186918
  • 2016-10-06 11:25:03
  • 365

【啊哈!算法】算法12:堆——神奇的优先队列(下)

接着上一Pa说。就是如何建立这个堆呢。可以从空的堆开始,然后依次往堆中插入每一个元素,直到所有数都被插入(转移到堆中为止)。因为插入第i个元素的所用的时间是O(log i),所以插入所有元素的整体...
  • ahalei
  • ahalei
  • 2014-06-17 09:35:55
  • 2476
收藏助手
不良信息举报
您举报文章:130. Heapify-堆化(siftup & siftdown版本)
举报原因:
原因补充:

(最多只允许输入30个字)