计数排序、 堆排序

堆排序

    class minheadSort {
      sort(arr) {
        let temp = []
        let heapArr = this.buildHeap(arr)
        while (heapArr.length) {
          temp.push(heapArr.shift());
          heapArr = this.buildHeap(heapArr);
        }
        return temp
      }

      buildHeap(arr) {
        let temp = []
        for (let i = 0; i < arr.length; i++) {
          this.insert(arr[i], temp)
        }
        return temp
      }
      insert(value, arr) {
        arr.push(value)
        this.shiftUp(arr.length - 1, arr)
      }
      getParentIndex(i) {
        return Math.floor((i - 1) / 2);
      }
      swap(i1, i2, arr) {
        const temp = arr[i1];
        arr[i1] = arr[i2];
        arr[i2] = temp;
      }
      shiftUp(index, arr) {
        if (index === 0) {
          return
        }
        const parentIndex = this.getParentIndex(index)
        if (arr[parentIndex] > arr[index]) {
          this.swap(parentIndex, index, arr)
          this.shiftUp(parentIndex, arr)
        }
      }
    }

计数排序 (非比较类的排序， 对于负数， 小数不能准确的进行排序)

    function countSort(arr) {
      let res = []
      for (let i = 0; i < arr.length; i++) {
        if (res[arr[i]] !== undefined) {
          res[arr[i]] = res[arr[i]] + 1
        } else {
          res[arr[i]] = 1
        }
      }
      let result = []
      for (let i = 0; i < res.length; i++) {
        // 把i添加 res[i]次
        if (res[i] !== undefined) {
          for (let j = 0; j < res[i]; j++) {
            result.push(i)
          }
        }
      }
      return result
    }