chapter 5: queues and deques

Author: loiane

src/05-queue-deque/01-using-queue-class.js

@@ -0,0 +1,26 @@
+// src/05-queue-deque/01-using-queue-class.js
+
+const Queue = require('./queue');
+
+const queue = new Queue();
+
+console.log(queue.isEmpty()); // true
+
+queue.enqueue({ document: 'Chapter05.docx', pages: 20 });
+queue.enqueue({ document: 'JavaScript.pdf', pages: 60 });
+queue.enqueue({ document: 'TypeScript.pdf', pages: 80 });
+
+console.log(queue.toString());
+
+console.log(queue.size); // 3
+
+console.log(queue.isEmpty()); // false
+
+console.log(queue.front()); // { document: 'Chapter05.docx', pages: 20 }
+
+// print all documents
+while (!queue.isEmpty()) {
+  console.log(queue.dequeue());
+}
+
+// to see the output of this file use the command: node src/05-queue-deque/01-using-queue-class.js

src/05-queue-deque/02-using-queue-two-pointers.js

@@ -0,0 +1,33 @@
+// src/05-queue-deque/02-using-queue-two-pointers.js
+
+const Queue = require('./queue-two-pointers');
+
+const queue = new Queue();
+
+console.log(queue.isEmpty()); // true
+
+queue.enqueue({ document: 'Chapter05.docx', pages: 20 });
+queue.enqueue({ document: 'JavaScript.pdf', pages: 60 });
+queue.enqueue({ document: 'TypeScript.pdf', pages: 80 });
+
+console.log(queue.toString());
+
+console.log(queue.size); // 3
+
+console.log(queue.isEmpty()); // false
+
+console.log(queue.front()); // { document: 'Chapter05.docx', pages: 20 }
+
+// print all documents
+while (!queue.isEmpty()) {
+  console.log(queue.dequeue());
+}
+
+// add more documents
+queue.enqueue({ document: 'DataStructures.pdf', pages: 400 });
+
+console.log(queue.toString());
+console.log(queue.size); // 1
+console.log(queue.front()); // { document: 'DataStructures.pdf', pages: 400 }
+
+// to see the output of this file use the command: node src/05-queue-deque/02-using-queue-two-pointers.js

src/05-queue-deque/03-using-deque-class.js

@@ -0,0 +1,44 @@
+// src/05-queue-deque/03-using-deque-class.js
+
+const Deque = require('./deque');
+
+class BrowserHistory {
+  #history = new Deque(); // Stores visited pages
+  #currentPage = null;
+
+  visit(url) {
+    this.#history.addFront(url);
+    this.#currentPage = url;
+  }
+
+  goBack() {
+    if (this.#history.size() > 1) { // Check if there's a previous page
+      this.#history.removeFront();  // Remove the current page
+      this.#currentPage = this.#history.peekFront(); // Set current to the previous
+    }
+  }
+
+  goForward() {
+    if (this.#currentPage !== this.#history.peekBack()) { // Check if there's a next page
+      this.#history.addFront(this.#currentPage);  // Add the current page back
+      this.#currentPage = this.#history.removeFront(); // Set current to the next page
+    }
+  }
+
+  get currentPage() {
+    return this.#currentPage;
+  }
+}
+
+const browser = new BrowserHistory();
+browser.visit('loiane.com');
+browser.visit('https://loiane.com/about'); // click on About menu
+
+browser.goBack();
+console.log(browser.currentPage); // loiane.com
+
+browser.goForward();
+console.log(browser.currentPage); // https://loiane.com/about
+
+
+// to see the output of this file use the command: node src/05-queue-deque/03-using-deque-class.js

src/05-queue-deque/__test__/deque.test.ts

@@ -0,0 +1,95 @@
+import {describe, expect, test, beforeEach} from '@jest/globals';
+import Deque from '../deque';
+
+describe('Deque', () => {
+  let deque: Deque<number>;
+
+  beforeEach(() => {
+    deque = new Deque<number>();
+  });
+
+  test('should add an element to the front of the deque', () => {
+    deque.addFront(1);
+    deque.addFront(2);
+    expect(deque.toString()).toBe('2, 1');
+  });
+
+  test('should add an element to the rear of the deque', () => {
+    deque.addRear(1);
+    deque.addRear(2);
+    expect(deque.toString()).toBe('1, 2');
+  });
+
+  test('should remove an element from the front of the deque', () => {
+    deque.addFront(1);
+    deque.addFront(2);
+    deque.removeFront();
+    expect(deque.toString()).toBe('1');
+  });
+
+  test('should return undefined when removing from an empty deque', () => {
+    expect(deque.removeFront()).toBeUndefined();
+  });
+
+  test('should remove an element from the rear of the deque', () => {
+    deque.addRear(1);
+    deque.addRear(2);
+    deque.removeRear();
+    expect(deque.toString()).toBe('1');
+  });
+
+  test('should return undefined when removing from an empty deque', () => {
+    expect(deque.removeRear()).toBeUndefined();
+  });
+
+  test('should return the front element of the deque', () => {
+    deque.addFront(1);
+    deque.addFront(2);
+    expect(deque.peekFront()).toBe(2);
+  });
+
+  test('should return undefined when peeking from an empty deque', () => {
+    expect(deque.peekFront()).toBeUndefined();
+  });
+
+  test('should return the rear element of the deque', () => {
+    deque.addRear(1);
+    deque.addRear(2);
+    expect(deque.peekRear()).toBe(2);
+  });
+
+  test('should return undefined when peeking from an empty deque', () => {
+    expect(deque.peekRear()).toBeUndefined();
+  });  
+
+  test('should return true if the deque is empty', () => {
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should return the size of the deque', () => {
+    deque.addFront(1);
+    deque.addFront(2);
+    expect(deque.size()).toBe(2);
+  });
+
+  test('should clear the deque', () => {
+    deque.addFront(1);
+    deque.addFront(2);
+    deque.clear();
+    expect(deque.isEmpty()).toBe(true);
+  });
+
+  test('should convert the deque to a string', () => {
+    expect(deque.toString()).toBe('Empty Deque');
+  });
+
+  test('should convert the deque to a string with objects', () => {
+    const deque = new Deque<{key: string, value: number}>();
+
+    deque.addFront({key: 'a', value: 1});
+    deque.addFront({key: 'b', value: 2});
+    deque.addFront({key: 'c', value: 3});
+
+    expect(deque.toString()).toBe('{"key":"c","value":3}, {"key":"b","value":2}, {"key":"a","value":1}');
+  });
+});

src/05-queue-deque/__test__/queue.test.ts

@@ -0,0 +1,83 @@
+import {describe, expect, test, beforeEach} from '@jest/globals';
+import Queue from '../queue';
+
+describe('Queue', () => {
+  let queue;
+
+  beforeEach(() => {
+    queue = new Queue();
+  });
+
+  test('should enqueue and dequeue elements correctly', () => {
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    expect(queue.dequeue()).toBe(1);
+    expect(queue.dequeue()).toBe(2);
+    expect(queue.dequeue()).toBe(3);
+    expect(queue.isEmpty()).toBe(true);
+  });
+
+  test('should return undefined when dequeueing from an empty queue', () => {
+    expect(queue.dequeue()).toBeUndefined();
+  });
+
+  test('should return the correct size after enqueueing and dequeueing elements', () => {
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    queue.dequeue();
+    queue.dequeue();
+
+    expect(queue.size()).toBe(1);
+  });
+
+  test('should return the correct front element after enqueueing and dequeueing elements', () => {
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    queue.dequeue();
+
+    expect(queue.front()).toBe(2);
+  });
+
+  test('should return undefined when calling front on an empty queue', () => {
+    expect(queue.front()).toBeUndefined();
+  });
+
+  test('should clear the queue and return the correct size', () => {
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    queue.clear();
+
+    expect(queue.isEmpty()).toBe(true);
+    expect(queue.size()).toBe(0);
+  });
+
+  test('should convert the queue to a string', () => {
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    expect(queue.toString()).toBe('1, 2, 3');
+  });
+
+  test('should convert the queue to a string with empty queue', () => {
+    expect(queue.toString()).toBe('Empty Queue');
+  });
+
+  test('should convert the queue to a string with object', () => {
+    queue.enqueue({name: 'John', age: 30});
+    queue.enqueue({name: 'Jane', age: 25});
+    queue.enqueue({name: 'Doe', age: 40});
+
+    expect(queue.toString()).toBe(
+      '{"name":"John","age":30}, {"name":"Jane","age":25}, {"name":"Doe","age":40}',
+    );
+  });
+});

src/05-queue-deque/deque.js

@@ -0,0 +1,57 @@
+// src/05-queue-deque/deque.js
+
+class Deque {
+  #items = [];
+
+  addFront(item) {
+    this.#items.unshift(item);
+  }
+
+  addRear(item) {
+    this.#items.push(item);
+  }
+
+  removeFront() {
+    return this.#items.shift();
+  }
+
+  removeRear() {
+    return this.#items.pop();
+  }
+
+  peekFront() {
+    return this.#items[0];
+  }
+
+  peekRear() {
+    return this.#items[this.#items.length - 1];
+  }
+
+  isEmpty() {
+    return this.#items.length === 0;
+  }
+
+  get size() {
+    return this.#items.length;
+  }
+
+  clear() {
+    this.#items = [];
+  }
+
+  toString() {
+    if (this.isEmpty()) {
+      return 'Empty Deque';
+    } else {
+      return this.#items.map(item => { // {1}
+        if (typeof item === 'object' && item !== null) { // {2}
+          return JSON.stringify(item); // Handle objects
+        } else {
+          return item.toString(); // Handle other types {3}
+        }
+      }).join(', '); // {4}
+    }
+  }
+}
+
+module.exports = Deque;