dist-javascript-algorithms-and-data-structures/dist/data-structures/stack/Stack.js

Algorithms and data-structures implemented on JavaScript

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _LinkedList = _interopRequireDefault(require("../linked-list/LinkedList"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Stack {
  constructor() {
    // We're going to implement Stack based on LinkedList since these
    // structures are quite similar. Compare push/pop operations of the Stack
    // with prepend/deleteHead operations of LinkedList.
    this.linkedList = new _LinkedList.default();
  }
  /**
   * @return {boolean}
   */


  isEmpty() {
    // The stack is empty if its linked list doesn't have a head.
    return !this.linkedList.head;
  }
  /**
   * @return {*}
   */


  peek() {
    if (this.isEmpty()) {
      // If the linked list is empty then there is nothing to peek from.
      return null;
    } // Just read the value from the start of linked list without deleting it.


    return this.linkedList.head.value;
  }
  /**
   * @param {*} value
   */


  push(value) {
    // Pushing means to lay the value on top of the stack. Therefore let's just add
    // the new value at the start of the linked list.
    this.linkedList.prepend(value);
  }
  /**
   * @return {*}
   */


  pop() {
    // Let's try to delete the first node (the head) from the linked list.
    // If there is no head (the linked list is empty) just return null.
    const removedHead = this.linkedList.deleteHead();
    return removedHead ? removedHead.value : null;
  }
  /**
   * @return {*[]}
   */


  toArray() {
    return this.linkedList.toArray().map(linkedListNode => linkedListNode.value);
  }
  /**
   * @param {function} [callback]
   * @return {string}
   */


  toString(callback) {
    return this.linkedList.toString(callback);
  }

}

exports.default = Stack;