算法导论第六章笔记

最新推荐文章于 2024-07-16 20:38:37 发布

Myriad_Dreamin

最新推荐文章于 2024-07-16 20:38:37 发布

阅读量254

点赞数

分类专栏：笔记文章标签：笔记算法导论

本文链接：https://blog.csdn.net/Myriad_Dreamin/article/details/79285612

版权

笔记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

第六章内容

1.因为卫星数据的关系，交换大规模数据交换指针会更加实用。
2.(二叉)堆可以由数组实现。作为数组实现，它拥有一个attribute: $heap-size[A]$ 表示数组 $A$ 中在堆中的元素个数。二叉与二进制紧密联系，使得它拥有一些优越的指令与算法相匹配。
3.保持堆的性质需要一系列函数，自顶向下可以细分为：
BUILD-HEAP<-HEAP-INSERT<-HEAPIFY

6.1.1：
根据二叉堆的定义最少有 $2^{h-1}+1$ 个元素，最多有 $2^h$ 个元素。
6.1.2：
由6.1.1得知 $lgn<h<lg(n-1)+1<lgn+1 \Leftrightarrow h=\lfloor lgn\rfloor$
6.1.3：
由数学归纳及大根堆性质 $A[parent(i)]\ge A[i]$ 可证。
6.1.4：
叶子结点处。
6.1.5：
是。
6.1.6：

                  23
         --------------------
         17                14
   --------------    --------------
   06          13    10          01
--------    --------
05    07    12    NL

第九个比父结点大，所以不是最大堆。
6.1.7：
分布在第 $2$ 层的节点失去叶子结点的资格当且仅当出现children即 $2i$ 或 $2i+1$ ，则第 $\lfloor n/2\rfloor$ 个节点恰好失去叶子结点的资格。所以第 $\lfloor n/2\rfloor+1、\lfloor n/2\rfloor+2、...、n$ 是叶子结点。
6.2.1：

begin-->
   03
--------
10    01
->
10<->3
->
   10
--------
03    01

-->
   03
--------
08    09
->
3<->9
->
   09
--------
08    03
-->
   03
--------
NL    NL
-->end

6.2.3：

MIN-HEAPIFY(A,i)
    p ← PARENT(i)
    if A[i] > A[p]
        then exchange A[i]↔A[p]
            MIN-HEAPFIY(A,p)

时间复杂度是 $O(h)$ ，但常数小于 $MAX-HEAPIFY()$
6.2.4：
因为没有子结点直接返回。
6.2.5：

MAX-HEAPIFY(A,i)
    largest ← 0
    while largest != i
        l ← LEFT(i)
        r ← RIGHT(i)
        if l <= heap-size[A] and A[l] > A[i]
            then largest ← l
            else largest ← i
        if r <= heap-size[A] and A[r] > A[largest]
            then largest ← r
        if largest!=i
            then exchange A[i]↔A[largest]
            i ← largest
            largest ← 0

6.2.5：
对 $A[i]=i$ 的数组建堆， $MAX-HEAPIFY(A,1)$ 花费的时间是 $\Omega(lgn)$
6.3.1：

begin-->
heap-size[A] ← 9
                  05
         --------------------
         03                17
   --------------    --------------
   10          84    19          06
--------
22    09
MAX-HEAPIFY(A,4)
-->
                  05
         --------------------
         03                17
   --------------    --------------
   22          84    19          06
--------
10    09
MAX-HEAPIFY(A,3)
-->
                  05
         --------------------
         03                19
   --------------    --------------
   22          84    17          06
--------
10    09
MAX-HEAPIFY(A,2)
-->
                  05
         --------------------
         84                19
   --------------    --------------
   22          03    17          06
--------
10    09
MAX-HEAPIFY(A,1)
                  84
         --------------------
         22                19
   --------------    --------------
   10          03    17          06
--------
05    09
-->END

6.3.2：
因为 $MAX-HEAPIFY()$ 只能向下更新，若先调用 $MAX-HEAPIFY(A,1)$ 根结点可能不是最大值。
6.3.3：
根据父子结点下标的关系
第一层至多有 $n-(\lfloor n/2 \rfloor+1)+1=\lceil n/2^{0+1}\rceil$ 个结点，第 $h+1(h>0)$ 层均恒有 $2^{\lfloor lgn \rfloor-h-1}=\lceil n/2^{h+1}\rceil$ 个结点
6.4.1：

begin-->
                  05
         --------------------
         13                02
   --------------    --------------
   25          07    17          20
--------
08    04
-->BUILD-MAX-HEAP(A)-->
                  25
         --------------------
         13                20
   --------------    --------------
   08          07    17          02
--------
05    04
<>
-->exchange(1,9),heap-size ← 8-->
                  04
         --------------------
         13                20
   --------------    --------------
   08          07    17          02
----
05
<25>
-->HEAPIFY(A,1)-->
                  20
         --------------------
         13                17
   --------------    --------------
   08          07    04          02
----
05
<25>
-->exchange(1,8),heap-size ← 7-->
                  05
         --------------------
         13                17
   --------------    --------------
   08          07    04          02
<20,25>
-->HEAPIFY(A,1)-->
                  17
         --------------------
         13                05
   --------------    --------------
   08          07    04          02
<20,25>
-->exchange(1,7),heap-size ← 6-->
                  02
         --------------------
         13                05
   --------------    -------
   08          07    04
<17,20,25>
-->HEAPIFY(A,1)-->
                  13
         --------------------
         08                05
   --------------    -------
   02          07    04
<17,20,25>
-->exchange(1,6),heap-size ← 5-->
                  04
         --------------------
         08                05
   --------------
   02          07
<13,17,20,25>
-->HEAPIFY(A,1)-->
                  08
         --------------------
         07                05
   --------------
   02          04
<13,17,20,25>
-->exchange(1,5),heap-size ← 4-->
                  04
         --------------------
         07                05
   -------
   02          
<8,13,17,20,25>
-->HEAPIFY(A,1)-->
                  07
         --------------------
         04                05
   -------
   02
<8,13,17,20,25>
-->exchange(1,4),heap-size ← 3-->
                  02
         --------------------
         04                05
<7,8,13,17,20,25>
-->HEAPIFY(A,1)-->
                  05
         --------------------
         04                02
<7,8,13,17,20,25>
-->exchange(1,3),heap-size ← 2-->
                  02
         ----------
         04
<5,7,8,13,17,20,25>
-->HEAPIFY(A,1)-->
                  04
         ----------
         02
<5,7,8,13,17,20,25>
-->exchange(1,2),heap-size ← 1-->
                  02
<4,5,7,8,13,17,20,25>
-->HEAPIFY(A,1)-->
                  02
<4,5,7,8,13,17,20,25>
-->END

6.4.2：
初始: $heap-size[A]$ =n， $A[1...n]$ 是包含n个最小的元素的最大堆， $A[n+1...n]$ 包含0个最大元素，这是正确的。
保持: $A[1]$ 是堆中最大的元素，所以 $A[1]$ 和 $A[i]$ 交换使得 $A[1...i-1]$ 成为包含 $i-1$ 个最小的元素的最大堆， $A[i...n]$ 包含 $n-i+1$ 个最大元素， $HEAPIFY(A,1)$ 使 $A[1...i-1]$ 保持堆的性质，建立起了循环不变式
终止： $i=2$ 时交换 $A[1]$ 和 $A[2]$ ，这就使得A[1]包含一个最小元素， $A[2...n]$ 包含 $n-1$ 个最大元素，实质上 $A[1...n]$ 已排序好。
6.4.3：
运行时间为 $T(n)=\sum_{i=2}^ {\lfloor length[A_i]/2\rfloor}c_i+\sum_{j=2}^ nC_j+O(1)$
最坏情况建堆 $O(n)$ ,根据6.3-3HEAPIFY的总时间复杂度至多为 $O(\sum_{i=2}^ nlg\lfloor heap-size[A_i]\rfloor)=O(lg(n!))=O(nlgn)$
6.4.4：
见6.4.3.
6.4.5：
不会证，暂且放着。
6.5.1：

begin-->
                     15
         --------------------------
         13                      09
   --------------          --------------
   05          12          08          07
--------    --------    ----
04    00    06    02    01
-->
max ← 15
A[1] ← 1
heap-size ← 11
-->
                     01
         --------------------------
         13                      09
   --------------          --------------
   05          12          08          07
--------    --------
04    00    06    02
-->HEAPIFY(A,1)-->
                     13
         --------------------------
         12                      09
   --------------          --------------
   05          06          08          07
--------    --------
04    00    01    02

6.5.2：

begin-->
heap-size ← 13
A[13] ← -INF
                     15
         --------------------------
         13                      09
   --------------          --------------
   05          12          08          07
--------    --------    --------
04    00    06    02    01    -INF
-->A[13] ← 10-->
                     15
         --------------------------
         13                      09
   --------------          --------------
   05          12          08          07
--------    --------    --------
04    00    06    02    01    10
-->
                     15
         --------------------------
         13                      09
   --------------          --------------
   05          12          10          07
--------    --------    --------
04    00    06    02    01    08
-->
                     15
         --------------------------
         13                      10
   --------------          --------------
   05          12          09          07
--------    --------    --------
04    00    06    02    01    08

6.5.3：

//返回堆顶
HEAP-MINUM(A)
    return A[1]
//删除并返回队首
HEAP-EXTRACT-MIN(A)
    if heap-size[A] < 1
        then error"heap underflow"
    min ← A[1]
    A[1] ← A[heap-size[A]]
    heap-size[A] ← heap-size[A]+1
    MIN-HEAPIFY(A,1)
    return min
//减少第i项值到key
HEAP-DECREASE-KEY(A,i,key)
    if i > heap-size[A]
        then error"A[i] is not in the heap"
    if key > A[i]
        then error"new key is bigger than current key"
    A[i] ← key
    p ← PARENT(i)
    while i > 1 and A[p] > A[i]
        do exchange A[i],A[p]
        i ← p
        p ← PARENT(i)
//使key入队
MIN-HEAP-INSERT(A,key)
    heap-size[A] ← heap-size[A]+1
    A[heap-size[A]] ← -INF
    HEAP-DECREASE-KEY(A,heap-size[A],key)

6.5.4：
使得HEAP-DECREASE-KEY总是成功
6.5.5：
初始:所给堆为最大堆因为 $A[i]< key$ ，所以 $A[i]$ 为根的子树保持了最大堆的性质，但 $key$ 和 $A[parent(i)]$ 的关系不确定，这是正确的。
保持:对于当前的 $i$ 与 $A[parent(i)]$ ，若 $A[parent(i)]<A[i]$ 根据算法交换 $A[parent(i)]$ 与 $A[i]$ ，根据最大堆的性质 $A[parent(i)]\ge A[i]$ 所以 $A[i] (因为交换了实际是A[parent(i)]的值)$ ，所以 $A[i]$ 为根的子树保持了最大堆的性质，但 $A[parent(i)]$ 和 $A[parent(parent(i))]$ 的关系不确定。我们注意到这保持了循环不变式，所以进入下一次迭代总是正确的。
终止： $A[parent(i)]>=A[i]$ 终止迭代，注意到这满足最大堆的性质，所以A[1…heap-size[A]]重新恢复成最大堆。
6.5.6：
对于每个即将入队（最小堆）的元素，我们增加一个attribute： $key=time()+1$ ,这就使得后进入的总是在最后， $FIFO$
对于每个即将入队（最大堆）的元素，我们增加一个attribute： $key=time()+1$ ,这就使得后进入的总是在最前， $FILO$
6.5.7：

HEAP-DELETE(A,i)
    HEAP-DECREASE-KEY(A,i,-INF)
    exchange A[i],A[heap-size[A]]
    MAX-HEAPIFY(A,i)
    heap-size[A] ← heap-size[A]-1

6.5.8：

//key=front[L[i]]
MERGE-SORTED-LIST(L)
    create list NL
    BUILD-MIN-HEAP(L)
    while heap-size[L] > 0
        PUSH-BACK(NL,HEAP-MINUM(L))
        POP(L[1])
        if list-size[L[1]] < 1
            then HEAP-EXTRACT-MIN(L)
            else MIN-HEAPIFY(L,1)
    return NL

思考题暂略。

Myriad_Dreamin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
算法导论第六章笔记

第六章内容1.因为卫星数据的关系，交换大规模数据交换指针会更加实用。 2.(二叉)堆可以由数组实现。作为数组实现，它拥有一个attribute:heap-size[A]表示数组A中在堆中的元素个数。二叉与二进制紧密联系，使得它拥有一些优越的指令与算法相匹配。 6.1.1：根据二叉堆的定义最少有2h−1+12h−1+12^{h-1}+1个元素，最多有2h2h2^h个元素。 6.1.2：...
复制链接

扫一扫