标签：siftdown int 基本原理 复杂度 节点 son void

什么是堆？

堆(Heap)是一种重要的数据结构，是实现优先队列(Priority Queues)首选的数据结构。堆有很多种变体，包括二项式堆、斐波那契堆等，但是这里只考虑最常见的二叉堆。

堆是一棵满足如下性质的二叉树：

1. 父节点的键值总是不大于它的孩子节点的键值（小顶堆）。
2. 父节点的键值总是不小于它的孩子节点的键值（大顶堆）。

由于堆是一棵形态规则的二叉树，因此堆的父节点和孩子节点存在如下关系（根节点编号为0）：
设父节点的编号为 i, 则其左孩子节点的编号为2i+1, 右孩子节点的编号为2i+2
设孩子节点的编号为i, 则其父节点的编号为(i-1)/2
由于上面的性质，父节点一定比他的儿节点小（大），所以整个树的树根的值一定是最小（最大）的，那么我们就能在O(1)的时间内，获得整个堆的极值。

堆的相关操作：

• 插入 - add(element)
  时间复杂度：O(logn)，先满足 结构特性（保证O(logn) 的特性），后满足 值特性，先无视值，放在底下的位置上，后往上遍历，直到遇到合适的位置。

• 取出 - poll()
  时间复杂度：O(logn)，先满足 结构特性（保证O(logn) 的特性），后满足 值特性，先将堆顶的值和堆底的值进行交换，再讲堆底的值（原堆顶）移除，后将堆顶的值（原堆底）往下遍历（与两个儿子中较小的进行交换），直到遇到合适的位置。

• 获得最大值or最小值
  时间复杂度：O(1)

如何在O(logn)取出堆的任意值？
需要HashMap的辅助，key为该堆中独特的识别符，value为在堆里的位置。

堆与优先队列的关系

优先队列是一种抽象的数据类型，它和堆的关系类似于，List和数组、链表的关系一样；我们常常使用堆来实现优先队列，因此很多时候堆和优先队列都很相似，它们只是概念上的区分。
优先队列的应用场景十分的广泛，常见的应用有：

• Dijkstra’s algorithm（单源最短路问题中需要在邻接表中找到某一点的最短邻接边，这可以将复杂度降低。）
• Huffman coding（贪心算法的一个典型例子，采用优先队列构建最优的前缀编码树(prefixEncodeTree)）
• Prim’s algorithm for minimum spanning tree（Prim的最小生成树算法）

在java，python中都已经有封装了的Priority Queue(Heaps)
优先队列是一个至少能够提供插入（Insert）和删除最小（DeleteMin）这两种操作的数据结构。对应于队列的操作，Insert相当于Enqueue，DeleteMin相当于Dequeue。

用堆实现优先的过程中，需要注意最大堆只能对应最大优先队列，最小堆则是对应最小优先队列。

什么是shiftup和shiftdown？

现在我们借助下面的问题，来理解shiftup和shiftdown的思想
给定一个数组A[]，我们的目的是要将 A[] 堆化，也就是让A[]满足以下要求：

A[i * 2 + 1] >= A[i]
A[i * 2 + 2] >= A[i]

• 基于 shiftup的版本 O(nlogn)

public class Solution {
    /**
     * @param A: Given an integer array
     * @return: void
     */
    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;
        }
    }
    
    public void heapify(int[] A) {
        for (int i = 0; i < A.length; i++) {
            siftup(A, i);
        }
    }
}

算法思路：
对于每个元素A[i]，比较A[i]和它的父亲结点的大小，如果小于父亲结点，则与父亲结点交换。
交换后再和新的父亲比较，重复上述操作，直至该点的值大于父亲。
时间复杂度分析：
对于每个元素都要遍历一遍，这部分是 O(n)
每处理一个元素时，最多需要向根部方向交换 logn次。
因此总的时间复杂度是 O(nlogn)

• 基于 Siftdown 的版本 O(n)

 public class Solution {
    /**
     * @param A: Given an integer array
     * @return: void
     */
    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;
        }
    }
    
    public void heapify(int[] A) {
        for (int i = (A.length - 1) / 2; i >= 0; i--) {
            siftdown(A, i);
        }
    }
}

Python版本：

import sys
import collections
class Solution:
    # @param A: Given an integer array
    # @return: void
    def siftdown(self, A, k):
        while k * 2 + 1 < len(A):
            son = k * 2 + 1    #A[i]左儿子的下标
            if k * 2 + 2 < len(A) and A[son] > A[k * 2 + 2]:
                son = k * 2 + 2    #选择两个儿子中较小的一个
            if A[son] >= A[k]:
                break
                
            temp = A[son]
            A[son] = A[k]
            A[k] = temp
            k = son
    
    def heapify(self, A):
        for i in range((len(A) - 1) // 2, -1, -1):
            self.siftdown(A, i)

算法思路： 初始选择最接近叶子的一个父结点，与其两个儿子中较小的一个比较，若大于儿子，则与儿子交换。 交换后再与新的儿子比较并交换，直至没有儿子。 再选择较浅深度的父亲结点，重复上述步骤。 时间复杂度分析 这个版本的算法，乍一看也是 O(nlogn)， 但是我们仔细分析一下，算法从第 n/2 个数开始，倒过来进行 siftdown。也就是说，相当于从 heap的倒数第二层开始进行 siftdown 操作，倒数第二层的节点大约有 n/4 个， 这 n/4 个数，最多 siftdown1次就到底了，所以这一层的时间复杂度耗费是 O(n/4)，然后倒数第三层差不多 n/8 个点，最多 siftdown2次就到底了。所以这里的耗费是 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)

堆排序

运用堆的性质，我们可以得到一种常用的、稳定的、高效的排序算法————堆排序。堆排序的时间复杂度为O(n*log(n))，空间复杂度为O(1)，堆排序的思想是：对于含有n个元素的无序数组nums, 构建一个堆(这里是小顶堆)heap，然后执行extractMin得到最小的元素，这样执行n次得到序列就是排序好的序列。
如果是降序排列则是小顶堆；否则利用大顶堆。

Trick
由于extractMin执行完毕后，最后一个元素last已经被移动到了root，因此可以将extractMin返回的元素放置于最后，这样可以得到sort in place的堆排序算法。
当然，如果不使用前面定义的heap，则可以手动写堆排序，由于堆排序设计到建堆和extractMin， 两个操作都公共依赖于siftDown函数，因此我们只需要实现siftDown即可。(trick:由于建堆操作可以采用siftUp或者siftDown，而extractMin是需要siftDown操作，因此取公共部分，则采用siftDown建堆)。

public class Solution {
    private void siftdown(int[] A, int left, int right) {
        int k = left;
        while (k * 2 + 1 <= right) {
            int son = k * 2 + 1;
            if (son + 1 <= right && A[son] < A[son + 1]) {
                son = k * 2 + 2;
            }
            if (A[son] <= A[k]) {
                break;
            }
            int tmp = A[son];
            A[son] = A[k];
            A[k] = tmp;
            k = son;
        }
    }
    
    public void heapify(int[] A) {
        for (int i = (A.length - 1) / 2; i >= 0; i--) {
            siftdown(A, i, A.length - 1);
        }
    }
    
    void sortIntegers(int[] A) {
        heapify(A);
        for (int i = A.length - 1; i > 0; i--) {
            int tmp = A[0];
            A[0] = A[i];
            A[i] = tmp;
            siftdown(A, 0, i - 1);
        }
    }
}

标签：siftdown,int,基本原理,复杂度,节点,son,void
来源： https://blog.csdn.net/m0_55221239/article/details/114538205

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。