LeetCode算法系列---【堆和堆排序（基础知识）】

---

堆和堆排序

---

1、堆

讲堆的话先从优先队列讲起；首先队列的特点是满足先入先出原则，也就是说输入数组为[2,3,4,6,8,5],则输出也为[2,3,4,6,8,5]；
那优先队列与队列的区别是什么呢？优先队列的“优先”指的是<最大/最小元素>优先出队，当队列为最大优先队列，无论入队顺序，当前最大的元素优先出队；当队列为最小优先队列，无论入队顺序，当前最小的元素优先出队。如上述数组若为最大优先队列，则输出元素应为[8,6,5,4,3,2]。
如需满足以上要求，简单的线性结构实现的时间复杂度较高(O(N))，因此考虑用堆的方式来实现。

–	入队	出队
普通数组	O(1)	O(N)
顺序数组	O(N)	O(1)
堆	O(logN)	O(logN)

2. 二叉堆(Binary Heap)

二叉堆的基本条件：
① 二叉堆是一个完全二叉树，也就是仅最后一层节点数不完全，除去最后一层其余层的节点个数为2^(L-1)，L为节点所在的层数（如root节点为第一层）；
② 以最大堆为例，堆中每个元素需满足：某个节点的值总是不大于其父节点的值
（本章均以最大堆为例）

Shift up添加元素

首先判断新加入的节点与其父节点的大小，若父节点小于新添加的节点，则交换两个节点。

Shift down添加元素

从堆中取出一个元素，并将最后一个节点放入堆顶中；同时调整堆节点的位置，使得堆仍满足最大堆的性质（比较父节点与左右孩子）。

堆结构的Python实现：

class MaxHeap():
    def __init__(self, capacity=None):
        self.capacity = capacity
        self.data = [None] * capacity
        self.count = 0

    def length(self):
        return self.count

    def isEmpty(self,):
        return self.count == 0

    # 插入一个元素
    def insert(self, item):
        self.data[self.count] = item
        self._shift_up(self.count)
        self.count += 1

    def _shift_up(self, k):
        while k and self.data[(k-1) // 2] < self.data[k]:
            self.data[(k-1) // 2], self.data[k] = self.data[k], self.data[(k-1) // 2]
            k = (k-1) // 2

    # 取出一个元素
    def extract(self):
        assert self.count > 0
        ret = self.data[0]
        # 将最后一个节点放至堆顶
        self.count -= 1
        self.data[0], self.data[self.count] = self.data[self.count], self.data[0]
        self._shift_down(0)
        return ret

    def _shift_down(self, k):
        # 仅需判断该节点是否有左孩子即可，因为在完全二叉树中，不存在只有右孩子而没有左孩子的节点；
        while 2 * k + 1 <= self.count:
            j = 2 * k + 1 # 在此循环中，self.data[k]  与self.data[j]交换位置
            # 判断左右孩子的大小
            if j + 1 <= self.count and self.data[j] < self.data[j + 1]:
                j += 1
            if self.data[k] >= self.data[j]:
                break
            self.data[k], self.data[j] = self.data[j], self.data[k]
            k = j

---

3. 堆排序

核心思想：
① 自底向上建堆：时间复杂度O(N)，具体推导可见知乎
② 交换根节点与尾结点，重新调整大跟对：时间复杂度O(NlogN)
【空间复杂度：O(1)】
注意：建堆时，也可以利用添加元素的方式建堆，即自上而下建堆，但该方式时间复杂度为O(NlogN)；每个元素需经过shift_up操作，其时间复杂度为O(logN).

class Solution:
    def heap_sort(self, nums):
        # 构建大根堆：从非叶子节点开始，逐渐向上
        for i in range((len(nums) - 1) // 2, -1, -1):
            self.build_heap(nums, i, len(nums))

        # 交换堆顶元素与尾结点，重新调整大根堆
        for i in range(len(nums)-1, -1, -1):
            nums[0], nums[i] = nums[i], nums[0]
            self.build_heap(nums, 0, i) # 时间复杂度：O(logn)
        return nums


    # shift_down
    def build_heap(self, nums, k, maxSize):
        while 2 * k + 1 < maxSize:
            j = 2 * k + 1
            # 比较左右孩子的值
            if j + 1 <= maxSize and nums[j] < nums[j + 1]:
                j += 1
			# 父节点k 与其左右孩子比较大小，若父节点值最大，则满足最大堆条件，退出循环
            if nums[k] >= nums[j]:
                break
			# 否则，交换父子节点，继续进入下一层进行堆的调整
            nums[k], nums[j] = nums[j], nums[k]
            k = j

---