⑩ 数据结构之“堆”

一、理论

1. 堆简介

• 堆是一种特殊的 完全二叉树
• 所有的节点都大于等于（最大堆）或小于等于（最小堆）它的子节点

1.1 js中的堆

• js中通常用数组表示堆
• 左侧子节点的位置是 2*index+1
• 右侧子节点的位置是 2*index+2
• 父节点位置是(index-1)/2

1.2 应用

• 堆能高效、快速找出最大值和最小值，时间复杂度O(1)
• 找出第k个最大（小）问题

2. js实现最小堆类

2.1 实现步骤

• 在类里声明一个数组，用来装元素
• 主要方法：插入、删除堆顶、获取堆顶、获取堆大小

class MinHeap {
  constructor() {
    this.heap = [];
  }
}

插入

• 将值插入堆的底部，即数组尾部
• 然后上移：将该值与父节点交换，知道父节点小于等于该值
• 大小为k的堆中插入元素的时间复杂度为O(logk)

class MinHeap {
  constructor() {
    this.heap = [];
  }
  swap(i1, i2) {
    const temp = this.heap[i1]
    this.heap[i1] = this.heap[i2]
    this.heap[i2] = temp
  }
  getParentIndex(i) {
    // return Math.floor((i-1)/2);
    return (i - 1) >> 1;
  }
  shiftUp(index) {
    if(index === 0) return;
    const parentIndex = this.getParentIndex(index);
    if(this.heap[parentIndex] > this.heap[index]) {
      this.swap(parentIndex, index);
      this.shiftUp(parentIndex);
    }
  }
  insert(value) {
    this.heap.push(value);
    this.shiftUp(this.heap.length-1);
  }
}

删除堆顶

• 用数组尾部元素替换堆顶（直接删除堆顶会破坏堆结构）
• 然后下移：将新堆顶和它的子节点进行交换，直到子节点大于等于新堆顶
• 大小为k的堆中删除堆顶的时间复杂度为O(logk)

class MinHeap {
  constructor() {
    this.heap = [];
  }
  swap(i1, i2) {
    const temp = this.heap[i1]
    this.heap[i1] = this.heap[i2]
    this.heap[i2] = temp
  }
  getLeftIndex(i) {
    return i * 2 + 1
  }
  getRightIndex(i) {
    return i * 2 + 2
  }
  shiftDown(index) {
    const leftIndex = this.getLeftIndex(index)
    const rightIndex = this.getRightIndex(index)
    if(this.heap[leftIndex] < this.heap[index]) {
      this.swap(leftIndex, index)
      this.shiftDown(leftIndex)
    }
    if(this.heap[rightIndex] < this.heap[index]) {
      this.swap(rightIndex, index)
      this.shiftDown(rightIndex)
    }
  }
  pop() {
    this.heap[0] = this.heap.pop()
    this.shiftDown(0)
  }
}

获取堆顶和堆大小

• 获取堆顶：返回数组的头部
• 获取堆的大小：返回数组的长度

class MinHeap {
  constructor() {
    this.heap = [];
  }
  peek() {
    return this.heap[0]
  }
  size() {
    return this.heap.length
  }
}

二、刷题

1. 数组中的第k个最大元素（215）

1.1 题目描述

• 给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素
• 请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素

1.2 解题思路

• 看到 第k个最大元素 --> 考虑选择使用最小堆

1.3 解题步骤

• 构建一个最小堆，并依次把数组的值插入堆中
• 当堆的容量超过k，删除堆顶
• 插入结束后，堆顶就是第k个最大元素

function findKthLargest(nums, k) {
  const h = new MinHeap()
  nums.forEach(n => {
    h.insert(n)
    if(h.size() > k) {
      h.pop()
    }
  })
  return h.peek()
}

1.4 时间复杂度 && 空间复杂度

• 时间复杂度：O(nlogk)
• 空间复杂度：O(k)

2. 前k个高频元素（347）

2.1 题目描述

• 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素
• 可以按 任意顺序 返回答案

直觉解法

function topKFrequent(nums, k) {
  const map = new Map()
  nums.forEach(n => {
    map.set(n, map.has(n) ? map.get(n)+1 : 1)
  })
  const list = [...map].sort((a, b) => b[1] - a[1])
  return list.slice(0, k).map(n => n[0])
}

• 时间复杂度：O(n)
• 空间复杂度：O(nlogn)

2.2 解题思路

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

2.3 解题步骤

function topKFrequent(nums, k) {
  const map = new Map()
  nums.forEach(n => {
    map.set(n, map.has(n) ? map.get(n)+1 : 1)
  })
  const h = new MinHeap()
  map.forEach((val, key) => {
    h.insert({ val, key })
    if(h.size() > k)  {
      h.pop()
    }
  })
  return h.heap.map(a => a.key)
}

2.4 时间复杂度 && 空间复杂度

• 时间复杂度：O(nlogk)
• 空间复杂度：O(n)

3. 合并k个排序链表（23）

3.1 题目描述

• 给你一个链表数组，每个链表都已经按升序排列
• 请你将所有链表合并到一个升序链表中，返回合并后的链表

3.2 解题思路

输入: lists = [ 1 -> 4 -> 5, 1 -> 3 -> 4, 2 -> 6 ]
输出：[1,1,2,3,4,4,5,6]

• 新链表的下一个节点一定是k个链表头中的最小节点 -> 考虑选择使用最小堆

3.3 解题步骤

• 构建最小堆，并依次把链表头插入堆中
• 弹出堆顶接到输出链表，并将堆顶所在链表的新链表头插入堆中
• 等堆元素全部弹出，合并工作就完成了

function mergeKLists(lists) {
  const res = new ListNode(0)
  const h = new MinHeap()
  let p = res
  lists.forEach(l => {
    if(l) h.insert(l)
  })
  while(h.size()) {
    const n = h.pop()
    p.next = n
    p = p.next
    if(n.next) h.insert(n.next)
  }
  return res.next
}

3.4 时间复杂度 && 空间复杂度

• 时间复杂度：O(nlogk)
• 空间复杂度：O(k)

三、总结 -- 技术要点

• 堆是一种特殊的 完全二叉树

• 所有的节点都大于等于（最大堆）或小于等于（最小堆）它的子节点

• js通常用数组表示堆

• 堆能高效、快速找出最大值和最小值，时间复杂度O(1)

• 找出第k个最大（小）问题