freeCodeCamp/curriculum/challenges/espanol/10-coding-interview-prep/data-structures/create-a-priority-queue-class.md

id, title, challengeType, forumTopicId, dashedName

id	title	challengeType	forumTopicId	dashedName
587d8255367417b2b2512c74	Crear una Clase Cola de Prioridad	1	301630	create-a-priority-queue-class

--description--

En este desafío crearás una Cola de Prioridad. Una cola de Prioridad es un tipo especial de cola en la que los elementos pueden tener una información adicional que especifica su proridad. Esto podría ser simplemente representado con un entero. La prioridad del elemento anulará el orden de colocación para determinar la secuencia de los elementos se debe sacar los elementos de la cola. Si un elemento con una prioridad más alta se pone en cola después de elementos con una prioridad más baja, el elemento con mayor prioridad será extraído antes que los demás elementos.

Por ejemplo, imaginemos que tenemos una cola de prioridad con tres elementos:

[['kitten', 2], ['dog', 2], ['rabbit', 2]]

Aquí el segundo valor ( un entero) representa la prioridad del elemento. Si ponemos en cola ['human', 1] con una prioridad 1 ( asumiendo que las prioridades inferiores tengan precedencia) entonces sería el primer elemento en ser extraído de la cola. La colección se vería así:

[['human', 1], ['kitten', 2], ['dog', 2], ['rabbit', 2]]

Hemos empezado a escribir una PriorityQueue en el editor de código. Necesitarás agregar un método enqueue para agregar elementos con una prioridad, un método dequeue para eliminar y devolver elementos, un método size que devuelva el número de elementos en la cola, un método front que devuelva el elemento al inicio de la cola, y finalmente un método isEmpty que devolverá true si la cola esta vacía o false si no lo está.

enqueue debe aceptar elementos con el formato mostrado arriba(['human', 1]) donde 1 representa la prioridad. dequeue y front debe devolver sole el nombre del elementos, no su prioridad.

--hints--

Tu clase PriorityQueue debe tener un método enqueue.

assert(
  (function () {
    var test = new PriorityQueue();
    return typeof test.enqueue === 'function';
  })()
);

Tu clase PriorityQueue debe tener una método dequeue.

assert(
  (function () {
    var test = new PriorityQueue();
    return typeof test.dequeue === 'function';
  })()
);

Tu clase PriorityQueue debe tener un método size.

assert(
  (function () {
    var test = new PriorityQueue();
    return typeof test.size === 'function';
  })()
);

Tu clase PriorityQueue debe tener un método front.

assert(
  (function () {
    var test = new PriorityQueue();
    return typeof test.front === 'function';
  })()
);

Tu clase PriorityQueue debe tener un método isEmpty.

assert(
  (function () {
    var test = new PriorityQueue();
    return typeof test.isEmpty === 'function';
  })()
);

Tu clase PriorityQueue debe guardar un seguimiento correctamente al número actual de elementos usando el método size como elementos encolados y desencolados.

assert(
  (function () {
    var test = new PriorityQueue();
    test.enqueue(['David Brown', 2]);
    test.enqueue(['Jon Snow', 1]);
    var size1 = test.size();
    test.dequeue();
    var size2 = test.size();
    test.enqueue(['A', 3]);
    test.enqueue(['B', 3]);
    test.enqueue(['C', 3]);
    return size1 === 2 && size2 === 1 && test.size() === 4;
  })()
);

El método front debe devolver el elemento correcto que está al frente de la cola ya que los elementos están encolados y desencolados.

assert(
  (function () {
    var test = new PriorityQueue();
    test.enqueue(['David Brown', 2]);
    var front1 = test.front();
    test.enqueue(['Jon Snow', 1]);
    var front2 = test.front();
    test.dequeue();
    test.enqueue(['A', 3]);
    var front3 = test.front();
    test.enqueue(['B', 3]);
    test.enqueue(['C', 3]);
    test.dequeue();
    var front4 = test.front();
    return (
      front1 === 'David Brown' &&
      front2 === 'Jon Snow' &&
      front3 === 'David Brown' &&
      front4 === 'A'
    );
  })()
);

El método isEmpty debe devolver true cuando la cola esté vacía.

assert(
  (function () {
    var test = new PriorityQueue();
    test.enqueue(['A', 1]);
    test.enqueue(['B', 1]);
    test.dequeue();
    var first = test.isEmpty();
    test.dequeue();
    return !first && test.isEmpty();
  })()
);

La cola de prioridad debe devolver los elementos con una prioridad mayor antes que los elementos con una prioridad más baja y devolver los elementos en orden first-in-first-out de lo contrario.

assert(
  (function () {
    var test = new PriorityQueue();
    test.enqueue(['A', 5]);
    test.enqueue(['B', 5]);
    test.enqueue(['C', 5]);
    test.enqueue(['D', 3]);
    test.enqueue(['E', 1]);
    test.enqueue(['F', 7]);
    var result = [];
    result.push(test.dequeue());
    result.push(test.dequeue());
    result.push(test.dequeue());
    result.push(test.dequeue());
    result.push(test.dequeue());
    result.push(test.dequeue());
    return result.join('') === 'EDABCF';
  })()
);

--seed--

--seed-contents--

function PriorityQueue () {
  this.collection = [];
  this.printCollection = function() {
    console.log(this.collection);
  };
  // Only change code below this line

  // Only change code above this line
}

--solutions--

function PriorityQueue() {
  this.collection = [];
  this.printCollection = function () {
    console.log(this.collection);
  };
  // Only change code below this line
  this.enqueue = function (newitem) {
    if (this.isEmpty()) {
      return this.collection.push(newitem);
    }

    this.collection = this.collection.reverse();
    var found_index = this.collection.findIndex(function (item) {
      return newitem[1] >= item[1];
    });
    if (found_index === -1) {
      this.collection.push(newitem);
    } else {
      this.collection.splice(found_index, 0, newitem);
    }
    this.collection = this.collection.reverse();
  };
  this.dequeue = function () {
    if (!this.isEmpty()) {
      return this.collection.shift()[0];
    } else {
      return "The queue is empty.";
    }
  };
  this.size = function () {
    return this.collection.length;
  };
  this.front = function () {
    return this.collection[0][0];
  };
  this.isEmpty = function () {
    return this.size() > 0 ? false : true;
  };
  // Only change code above this line
}