js数据结构——优先队列 堆排序

优先队列

优先队列API

class MaxPQ () {
  constructor (arr) {
    this.MaxPQ = [];
    if(arr != undefined) {
        this.MaxPQ = arr.slice();
    }
  }
  max () {} //返回最大元素
  delMax () {} //删除并返回最大元素
  isEmpty () {} //队列是否为空
  size () {} //返回元素个数
}

堆

定义：在二叉堆中，每个元素都要保证大于等于另两个特定位置的元素。当一棵二叉树的每个节点都大于等于它的两个子节点时，它被称为堆有序。

class MaxPQ {
  constructor (arr) {
    this.MaxPQ = ["-"];
    if(arr != undefined) {
        this.MaxPQ = this.MaxPQ.concat(arr.slice());
    }
    this.N = this.MaxPQ.length-1;
  }
  insert (num) {//插入元素
    this.MaxPQ.push(num);
    let index = this.MaxPQ.length-1;
    swim(this.MaxPQ, index);
    this.N++;
  }
  max () {//返回最大元素
    return this.MaxPQ[1];
  } 
  delMax () {//删除并返回最大元素
    if(this.N === 0){
        return null；
    }
    let max = this.MaxPQ[1]; 
    exch(this.MaxPQ, 1, this.N);
    this.MaxPQ[this.N] = null;
    this.N--;
    sink(this.MaxPQ,1);
    return max;
  } 
  isEmpty () {
    return this.N === 0;
  } //队列是否为空
  size () {
    return this.N;
  } //返回元素个数
}


function exch(arr, i, j){
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

function swim (arr, k) {//上浮
    while (k > 1 && arr[k] > arr [ Math.floor(k/2) ]){
        exch(arr, k, Math.floor(k/2));
        k = Math.floor(k/2);
    }
}

function sink (arr, k) {//下沉
    let N=arr.length - 1;
    while (2*k <= N) {
        let j = 2 * k;
        if(j < N && arr[j] < arr[j+1]){ j++; };
        if(arr[k] < arr[j]){
            exch(arr, k, j);
        }
        k = j;
    }
    return k;
}

堆排序

• 优势 ：能在插入操作和删除最大元素操作的混合动态场景中保证对数级别的运行时间。

function exch(arr, i, j){
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
function sink (arr, k, n) {//下沉, 为末端大小。
    let N=n;
    while (2*k <= N) {
        let j = 2 * k;
        if(j < N && arr[j] < arr[j+1]){ j++; };
        if(arr[k] < arr[j]){
            exch(arr, k, j);
        }
        k = j;
    }
    return k;
}

function sort(arr){
    arr.unshift('-');
    let n = arr.length-1;
    for(let i = 1; i < arr.length; i++) {
        swim(arr, i,  n);
    }
    while (n > 1){
        exch(arr, 1, n--);
        sink(arr, 1, n);
    }
    arr.shift();
    return arr.slice();
}