JS Linked Queue

A queue data structure implemented as a dubly linked list with Typesctipt with support for generic types.

Changelog

• 0.2.1
  • first method now return type T instead Node<T>

Installation

Install the package using a javascript package manager:

1. Yarn

  > yarn add js-linked-queue

2. Npm

  > npm install --save js-linked-queue

Usage

Using js-linked-queue is simple and can be used either with Javascript or Typescript.

Here an example with typescript

  import { Queue } from "js-linked-queue";

  // Because the queue supports generics you can 
  // put anything as a value for a queue node
  class Person {
    public name;
    public age;
    constructor(name, age) {
      this.name = name;
      this.age = age;
    }
  }

  // Create the queue
  const peopleQueue = new Queue<Person>();

  // To add people to queue use the enqueue function
  peopleQueue.enqueue(new Person("Mark", 23));
  peopleQueue.enqueue(new Person("Lucas", 43));

  // To delete an item from the head of the queue use dequeue
  peopleQueue.dequeue(); // reduce the queue size by one element

  // Use first() to get the head of the queue
  peopleQueue.first(); // Person { name: Lucas, age: 43}

  // You can even populate a queue from an existing object array
  const people: Person[] = [
    new Person("Alex", 23),
    new Person("Mary", 52),
    new Person("Alice", 19),
    new Person("Rita", 79),
    new Person("Frank", 57)
  ];

  const family = new Queue<Person>(people);

  // With a for-of loop you can iterate through the queue's elements:
  for(const relative of family) {
    console.log(`Hello, ${relative.name}`);
  }

Simple usage for javascript version of the example.

Api

Queue's apis.

1. Queue<T>.constructor(input: T[] = [])

   The default queue constructor accept an array of generic type T that by default is set as an empty array

2. instance.enqueue(item:T): boolean

   The enqueue method take an item of type T and return a boolean: true for correct enqueuing, false otherwise

3. instance.dequeue(): T

   The dequeue method is used to remove an element from the head of the queue and returns the value T of the Node<T> deleted from the queue

4. instance.first(): T

   The first method return the value of type T inside the head node of the queue

5. instance.isEmpty(): boolean

   The isEmpty method return a boolean; true if the queue is empty otherwise false

6. instance.size(): number

   The size method return the queue size as a number

7. instance.clear(): void

   The clear method is used to completely delete the queue's elements

8. [Symbol.iterator]

   Used for iterating though the queue's elements