fix: format files TheAlgorithms#1298

Author: paulinegarelli

Data-Structures/Heap/KeyPriorityQueue.js

@@ -1,15 +1,15 @@
 /**
  * KeyPriorityQueue is a priority queue based on a Minimum Binary Heap.
- * 
- * Minimum Binary Heaps are binary trees which are filled level by level 
+ *
+ * Minimum Binary Heaps are binary trees which are filled level by level
  * and then from left to right inside a depth level.
- * Their main property is that any parent node has a smaller or equal priority to all of its children, 
+ * Their main property is that any parent node has a smaller or equal priority to all of its children,
  * hence the root of the tree always has the smallest priority of all nodes.
- * 
+ *
  * This implementation of the Minimum Binary Heap allows for nodes to contain both a key and a priority.
  * WARNING: keys must be Integers as they are used as array indices.
- * 
- * In this implementation, the heap is represented by an array with nodes ordered 
+ *
+ * In this implementation, the heap is represented by an array with nodes ordered
  * from root-to-leaf, left-to-right.
  * Therefore, the parent-child node relationship is such that
  *      * the children nodes positions relative to their parent are: (parentPos * 2 + 1) and (parentPos * 2 + 2)
@@ -18,38 +18,37 @@
  * More information and visuals on Binary Heaps can be found here: https://www.geeksforgeeks.org/binary-heap/
  */
 
-
 // Priority Queue Helper functions
-function getParentPosition(position) {
+function getParentPosition (position) {
   // Get the parent node of the current node
   return Math.floor((position - 1) / 2)
 }
-function getChildrenPosition(position) {
+function getChildrenPosition (position) {
   // Get the children nodes of the current node
   return [2 * position + 1, 2 * position + 2]
 }
 
 class KeyPriorityQueue {
   // Priority Queue class using Minimum Binary Heap
-  constructor() {
+  constructor () {
     this._heap = []
     this.keys = {}
   }
 
   /**
    * Checks if the heap is empty
-   * @returns boolean 
+   * @returns boolean
    */
-  isEmpty() {
+  isEmpty () {
     return this._heap.length === 0
   }
 
   /**
    * Adds an element to the queue
-   * @param {number} key 
-   * @param {number} priority 
+   * @param {number} key
+   * @param {number} priority
    */
-  push(key, priority) {
+  push (key, priority) {
     this._heap.push([key, priority])
     this.keys[key] = this._heap.length - 1
     this._shiftUp(this.keys[key])
@@ -59,7 +58,7 @@ class KeyPriorityQueue {
    * Removes the element with least priority
    * @returns the key of the element with least priority
    */
-  pop() {
+  pop () {
     this._swap(0, this._heap.length - 1)
     const [key] = this._heap.pop()
     delete this.keys[key]
@@ -69,10 +68,10 @@ class KeyPriorityQueue {
 
   /**
    * Checks whether a given key is present in the queue
-   * @param {number} key 
+   * @param {number} key
    * @returns boolean
    */
-  contains(key) {
+  contains (key) {
     return (key in this.keys)
   }
 
@@ -81,7 +80,7 @@ class KeyPriorityQueue {
    * @param {number} key the element to change
    * @param {number} priority new priority of the element
    */
-  update(key, priority) {
+  update (key, priority) {
     const currPos = this.keys[key]
     this._heap[currPos][1] = priority
     const parentPos = getParentPosition(currPos)
@@ -100,15 +99,11 @@ class KeyPriorityQueue {
 
   _getPriorityOrInfinite (position) {
     // Helper function, returns priority of the node, or Infinite if no node corresponds to this position
-    if (position >= 0 && position < this._heap.length) {
-      return this._heap[position][1]
-    }
-    else {
-      return Infinity
-    }
+    if (position >= 0 && position < this._heap.length) return this._heap[position][1]
+    else return Infinity
   }
 
-  _shiftUp(position) {
+  _shiftUp (position) {
     // Helper function to shift up a node to proper position (equivalent to bubbleUp)
     let currPos = position
     let parentPos = getParentPosition(currPos)
@@ -121,20 +116,19 @@ class KeyPriorityQueue {
       parentPos = getParentPosition(currPos)
       currPriority = this._getPriorityOrInfinite(currPos)
       parentPriority = this._getPriorityOrInfinite(parentPos)
-
     }
     this.keys[this._heap[currPos][0]] = currPos
   }
 
-  _shiftDown(position) {
+  _shiftDown (position) {
     // Helper function to shift down a node to proper position (equivalent to bubbleDown)
     let currPos = position
     let [child1Pos, child2Pos] = getChildrenPosition(currPos)
     let child1Priority = this._getPriorityOrInfinite(child1Pos)
     let child2Priority = this._getPriorityOrInfinite(child2Pos)
     let currPriority = this._getPriorityOrInfinite(currPos)
 
-    if (currPriority == Infinity) {
+    if (currPriority === Infinity) {
       return
     }
 
@@ -153,12 +147,12 @@ class KeyPriorityQueue {
     }
   }
 
-  _swap(position1, position2) {
+  _swap (position1, position2) {
     // Helper function to swap 2 nodes
     [this._heap[position1], this._heap[position2]] = [this._heap[position2], this._heap[position1]]
     this.keys[this._heap[position1][0]] = position1
     this.keys[this._heap[position2][0]] = position2
   }
 }
 
-export { KeyPriorityQueue }
+export { KeyPriorityQueue }

Data-Structures/Heap/test/KeyPriorityQueue.test.js

@@ -1,23 +1,21 @@
 import { KeyPriorityQueue } from '../KeyPriorityQueue.js'
 
 describe('Method isEmpty', () => {
-
   test('Check heap is empty', () => {
     const queue = new KeyPriorityQueue()
-    let res = queue.isEmpty()
+    const res = queue.isEmpty()
     expect(res).toEqual(true)
   })
 
   test('Check heap is not empty', () => {
     const queue = new KeyPriorityQueue()
     queue.push(0, 2)
-    let res = queue.isEmpty()
+    const res = queue.isEmpty()
     expect(res).toEqual(false)
   })
 })
 
 describe('Methods push and pop', () => {
-
   test('Test Case 1', () => {
     // create queue
     const queue = new KeyPriorityQueue()
@@ -34,7 +32,7 @@ describe('Methods push and pop', () => {
     queue.pop()
     expect(queue).toEqual(expectedQueue)
   })
-  
+
   test('Test Case 2', () => {
     // create queue
     const queue = new KeyPriorityQueue()
@@ -51,7 +49,7 @@ describe('Methods push and pop', () => {
     queue.pop()
     expect(queue).toEqual(expectedQueue)
   })
-  
+
   test('Test Case 3', () => {
     // create queue
     const queue = new KeyPriorityQueue()
@@ -73,23 +71,21 @@ describe('Methods push and pop', () => {
 })
 
 describe('Method contains', () => {
-
   test('Check heap does not contain element', () => {
     const queue = new KeyPriorityQueue()
-    let res = queue.contains(0)
+    const res = queue.contains(0)
     expect(res).toEqual(false)
   })
 
   test('Check heap contains element', () => {
     const queue = new KeyPriorityQueue()
     queue.push(0, 2)
-    let res = queue.contains(0)
+    const res = queue.contains(0)
     expect(res).toEqual(true)
   })
 })
 
 describe('Method update', () => {
-
   test('Update without change in position', () => {
     // create queue
     const queue = new KeyPriorityQueue()
@@ -125,4 +121,4 @@ describe('Method update', () => {
     queue.update(0, 9)
     expect(queue).toEqual(expectedQueue)
   })
-})
+})

Graphs/PrimMST.js

@@ -1,4 +1,4 @@
-import { KeyPriorityQueue } from "../Data-Structures/Heap/KeyPriorityQueue"
+import { KeyPriorityQueue } from '../Data-Structures/Heap/KeyPriorityQueue'
 class GraphWeightedUndirectedAdjacencyList {
   // Weighted Undirected Graph class
   constructor () {

Graphs/test/PrimMST.test.js

@@ -1,20 +1,20 @@
 import { GraphWeightedUndirectedAdjacencyList } from '../PrimMST.js'
 
 test('Test Case PrimMST 1', () => {
-    // create graph to compute MST on
-    const graph = new GraphWeightedUndirectedAdjacencyList()
-    graph.addEdge(1, 2, 1)
-    graph.addEdge(2, 3, 2)
-    graph.addEdge(3, 4, 1)
-    graph.addEdge(3, 5, 100) // Removed in MST
-    graph.addEdge(4, 5, 5)
-    // create expected graph
-    const expectedGraph = new GraphWeightedUndirectedAdjacencyList()
-    expectedGraph.addEdge(1, 2, 1)
-    expectedGraph.addEdge(2, 3, 2)
-    expectedGraph.addEdge(3, 4, 1)
-    expectedGraph.addEdge(4, 5, 5)
-    // result from MST
-    const res = graph.PrimMST(1)
-    expect(res).toEqual(expectedGraph)
-})
+  // create graph to compute MST on
+  const graph = new GraphWeightedUndirectedAdjacencyList()
+  graph.addEdge(1, 2, 1)
+  graph.addEdge(2, 3, 2)
+  graph.addEdge(3, 4, 1)
+  graph.addEdge(3, 5, 100) // Removed in MST
+  graph.addEdge(4, 5, 5)
+  // create expected graph
+  const expectedGraph = new GraphWeightedUndirectedAdjacencyList()
+  expectedGraph.addEdge(1, 2, 1)
+  expectedGraph.addEdge(2, 3, 2)
+  expectedGraph.addEdge(3, 4, 1)
+  expectedGraph.addEdge(4, 5, 5)
+  // result from MST
+  const res = graph.PrimMST(1)
+  expect(res).toEqual(expectedGraph)
+})