首页 > 代码库 > 数据结构 之 二叉堆(Heap)

数据结构 之 二叉堆(Heap)

注:本节主要讨论最大堆(最小堆同理)。


一、堆的概念
    堆,又称二叉堆。同二叉查找树一样,堆也有两个性质,即结构性和堆序性。
    1、结构性质:
    堆是一棵被全然填满的二叉树。有可能的例外是在底层。底层上的元素从左到右填入。这种树称为全然二叉树(complete binary tree)。下图就是这样一个样例。
    技术分享
    对于全然二叉树,有这样一些性质:
    (1)、一棵高h的全然二叉树,其包括2^h ~ (2^(h+1) - 1)个节点。也就是说。全然二叉树的高是[logN],显然它是O(logN)。

    (2)、全然二叉树能够用数组进行结构表示:

index

0

1

2

3

4

5

6

7

8

9

10

11

12

13

value


A

B

C

D

E

F

G

H

I

J




    细致考察该数组的index和元素在树中的分布情况,能够得到:
    对于一个三元素的二叉树。树结构和数组索引有例如以下关系:
    leftChild.index = 2 * parent.index;
    rightChild.index = 2 * parent.index + 1; 
    (3)、通过前面的讨论。我们能够这样去看待一个堆的数据结构:
    一个数组、当前堆的大小heapLen。

    2、堆序性质:
    使操作被高速运行的性质是堆序性(heap order)。
    堆序性质:在一个堆中。对于每个节点x。x的父亲中的keyword大于(或等于)x中的keyword,根节点除外(它没有父节点)。
    依据堆序性质。最大元总能够在根处找到。

因此,我们以常数时间完毕查找操作。

    比較:
    堆序性质的堆:
    技术分享
    无堆序性质的堆:
    技术分享

二、基本堆操作

    声明:
    int heap[MAX+1];
    int heapLen; //堆的大小

    int leftEle(int i){ return i*2; }
    int rightEle(int i){ return i*2+1; }
    int parentEle(int i){ return i/2; }
    void swap(int i, int j){
        int tmp;
        tmp = i, i = j, j = tmp;
    }

    1、查询操作:    

    int findMax()
    {
        return heap[1];
    }

    函数解析:
    堆的最大值即为根节点元素,直接返回该值就可以。



    2、堆维护操作:

    下沉操作:
    void maxHeapify(int i)
    {
        int iLeft = leftEle(i);    //找到该节点的左儿子
        int iRight = rightEle(i);    //找到该节点的右儿子
        int largest = i;    //记录最大值节点,初始为节点自己
        
        //找到最大值相应的节点
        if( iLeft < heapLen && heap[i] < heap[iLeft] )
            largest = iLeft;
        if(iRight < heapLen && heap[largest] < heap[iRight] )
            largest = iRight;
        
        //交换原节点与最大值相应的节点,然后对交换后的节点进行堆维护操作
        if(largest != i)
        {
            swap(heap[i], heap[largest]);
            maxHeapify(largest);
        }
    }

    3、建堆操作:    

    在给出详细如何建堆的操作之前。我们能够考察一下详细应该如何去实现。

    如今给出一个堆(应该不能称之为堆),这个堆由初始数组构造而成,其结构为:
    技术分享
    显然这不是最大堆。
    整个数组为:    
index
83
11
6
15
36
19
value
1
2
3
4
5
6
    经过一系列的操作,我们须要将该堆转换为:
    技术分享
    整个最大堆化过程是这种:自下而上逐层维护堆操作。
    首先,找到第一个有子树的节点。对该节点进行堆维护操作,然后依次向上,进行堆维护。


    这里的问题:
    第一个有子树的节点在哪里?
    ===>>>>>
    对于全然二叉树,叶子节点必定存放在数组的尾端,如今的问题就在于叶子节点究竟有多少个?知晓叶子节点的个数后,就能够非常easy地确定有子树节点的位置。

那么叶子节点究竟有多少个呢?

    设全然二叉树总共同拥有n个节点。叶子节点有n0个,因为二叉树的节点的度数最大为2。于是可设度数为1的节点数为n1,度数为2的节点数为n2。
    于是我们能够得到这样几个关系式:
    n0+n1+n2 = n;
    n-1 = 2*n2 + n1;(边数的两种不同表示方式)
    解此方程式。能够得到:    
    n0 = (n+1-n1)/2.
    对于全然二叉树,n1 = 1或0
    当n1=1时。n0=n/2;当n1=0时,n0=(n+1)/2。
    于是我们能够得到叶子节点为总节点数的一半。
    从而有,非叶子节点应该是数组的前半部分。

    ===>>>
    void buildHeap()
    {    
        int i;
        for( i = heapLen/2; i > 0; i--)
            maxHeapify(i);
    }

    4、排序操作:    

    堆排序的关键在于将最大值元素交换到数组尾端,又一次进行堆维护操作。依次循环操作,即能够得到排序的数组。
    void heapSort()
    {
        int i;
        buileHeap();
        for( i=heapLen; i>=1; i--)
        {
            swap(heap[heapLen], heap[1]);
            heapLen--;
            maxHeapify(1);
        }
    }
    
    函数解析:
    首先我们先利用堆排序对一数组中的元素进行排序:
23
1
16
9
54
    技术分享
    如今进行堆排序:
    a、建堆:
    技术分享
    b、交换54和1,并解除堆最后一个元素与原堆的关系:
    技术分享
    c、重构堆:
    技术分享
    d、依次循环终于得到:
    技术分享
    这样,数组变为:
1
9
16
23
54
    从而完毕了对数组的排序。



    5、插入元素操作:    

    插入insertHeap():该操作同优先队列(priority queue)中的push操作。
    在介绍详细的插入操作前,须要实现increaseKey(int i, int key)函数,用于更新堆结构。

    上浮操作:
    void increaseKey(int i, int key)
    {
        assert(key >= heap[i]);    //断言key值大于heap[i]。假设不成立,则终止并报错
        heap[i] = key;
        while(i > 1 && heap[parentEle(i)] < heap[i])
        {
            swap(heap[i], heap[parentEle(i)]);
            i = parentEle(i);
        }
    }
    在这里,须要着重介绍一下increaseKey操作的详细步骤。举例说明:
    对于这样一个堆,将节点6的值由8添加到54—>>>:
  技术分享
    整个操作过程即为increaseKey(6, 54)。
    整个步骤例如以下:
  技术分享
    于是。插入元素到堆的代码例如以下:
    void insertHeap( int x )
    {
        heapLen++;
        heap[heapLen] = -INF;
        increaseKey(heapLen, x);
    }

    6、删除元素操作:

    删除deleteHeapMax():相当于优先队列中的pop()操作。

    int deleteHeapMax()
    {
        int ret = heap[1];
        swap(ret, heap[heapLen]);
        heapLen--;
        maxHeapify(1);
        return ret;
    }

三、算法分析:
查询操作
O(1)
堆维护操作
O(logN)
建堆操作
O(NlogN)
堆排序操作
O(NlogN)

数据结构 之 二叉堆(Heap)