algs4js/dist/sorting/MemorySort.js

Basic algorithms and data structures implemented with es6

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/**
 * Class MemorySort
 *
 *  Placeholder class for practicing sort coding by memory
 */
var MemorySort = function () {
  function MemorySort() {
    _classCallCheck(this, MemorySort);
  }

  _createClass(MemorySort, null, [{
    key: "heapSort",
    value: function heapSort(arr) {
      this.buildHeap(arr);
      for (var size = arr.length; size > 0; size--) {
        this.swap(arr, 0, size - 1);
        this.trickleDown(arr, size - 1, 0);
      }
    }
  }, {
    key: "buildHeap",
    value: function buildHeap(arr) {
      var lastParent = this.parent(arr.length - 1);
      for (var i = lastParent; i >= 0; i--) {
        this.trickleDown(arr, arr.length - 1, i);
      }
    }
  }, {
    key: "trickleDown",
    value: function trickleDown(arr, size, i) {
      var k = i;
      while (k < size) {
        var largest = k;
        var left = this.left(k);
        var right = this.right(k);
        if (left < size && arr[left] > arr[k]) {
          largest = left;
        }
        if (right < size && arr[right] > arr[largest]) {
          largest = right;
        }
        if (k !== largest) {
          this.swap(arr, k, largest);
          k = largest;
        } else {
          return;
        }
      }
    }

    /* eslint no-param-reassign: 0 */

  }, {
    key: "swap",
    value: function swap(arr, i, j) {
      var tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
    }
  }, {
    key: "parent",
    value: function parent(i) {
      return Math.floor((i - 1) / 2);
    }
  }, {
    key: "left",
    value: function left(i) {
      return 2 * i + 1;
    }
  }, {
    key: "right",
    value: function right(i) {
      return 2 * i + 2;
    }
  }]);

  return MemorySort;
}();

var arr = [3, 1, 2, 5, 4, 0];
console.log("Memory selection sorting array " + arr);
// MemorySort.selectionSort(arr);
// MemorySort.insertionSort(arr);
// MemorySort.quickSort(arr);
MemorySort.heapSort(arr);
console.log("After Memory selection sorting array " + arr);

exports.default = MemorySort;