347、前 K 个高频元素 | 堆-JS

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

示例 1:

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

示例 2:

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

提示：

• 1 <= nums.length <= 105
• k 的取值范围是 [1, 数组中不相同的元素的个数]
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。

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 (i-1) >> 1;  //二进制右移相当于除以2
  }
  getLeftIndex(i) {  //获取左结点
    return i * 2 + 1;
  }
  getRightIndex(i) {  //获取右结点
    return i * 2 + 2;
  }

  shiftUp(index){   //需要让父节点不断小于它的子节点
    if(index == 0){ return; }  //如果已经是根结点了就不用找了
    const parentIndex = this.getParentIndex(index);
    if(this.heap[parentIndex] && this.heap[parentIndex].value > this.heap[index].value){
      this.swap(parentIndex, index);  //如果父节点的值大于子节点则进行交换
      this.shiftUp(parentIndex)
    }
  }
  insert(value){  //插入，添加的方法
    this.heap.push(value);
    this.shiftUp(this.heap.length - 1);  //shiftUp就是上移操作，接收参数是上移时的下标
  }
  shiftDown(index){  //下移节点，直到子节点都大于当前节点的值
    // 需要获取它的左右子节点
    const leftIndex = this.getLeftIndex(index);
    const rightIndex = this.getRightIndex(index);
    if(this.heap[leftIndex] && this.heap[leftIndex].value < this.heap[index].value){  //小顶堆，父节点小于子节点
      this.swap(leftIndex, index);
      this.shiftDown(leftIndex);  //迭代，直到找到合适的位置
    }
    if(this.heap[rightIndex] && this.heap[rightIndex].value < this.heap[index].value){  //小顶堆，父节点小于子节点
      this.swap(rightIndex, index);
      this.shiftDown(rightIndex);  //迭代，直到找到合适的位置
    }
  }

  pop(){   //下移方法
    this.heap[0] = this.heap.pop();  // 把数组的最后一位转移到头部，相当于变相删除堆顶
    this.shiftDown(0);  //传什么下标，就对那个进行下移操作
  }
  peek(){ //获取堆顶，返回数组的头部
    return this.heap[0];
  }
  size(){  // 获取堆的大小
    return this.heap.length;
  }
}
/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var topKFrequent = function(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((value, key) => {
        h.insert({ value,key });
        if(h.size() > k){  //超出堆的大小之后，就弹出来
            h.pop()  //把堆顶的删除，最小的元素在堆顶
        }
    });
    return h.heap.map( a => a.key)
};

 小顶堆的数据结构：

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 (i-1) >> 1;  //二进制右移相当于除以2
  }
  getLeftIndex(i) {  //获取左结点
    return i * 2 + 1;
  }
  getRightIndex(i) {  //获取右结点
    return i * 2 + 2;
  }

  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);  //shiftUp就是上移操作，接收参数是上移时的下标
  }
  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);  //传什么下标，就对那个进行下移操作
  }
  peek(){ //获取堆顶，返回数组的头部
    return this.heap[0];
  }
  size(){  // 获取堆的大小
    return this.heap.length;
  }
}