Merge branch 'master' of https://github.com/Narahari-Sundaragopalan/JavaScript-Interview-Questions

Author: Narahari-Sundaragopalan

FE-JS-Questions/Carousel.md

@@ -21,7 +21,7 @@
 	</div>
 
 	<button class="carouselButton carouselButtonRight">
-		<img src="images/left.svg" alt="" />
+		<img src="images/right.svg" alt="" />
 	</button>
 
 	<div class="carouselNavigation">
@@ -195,4 +195,4 @@ dotsNav.addEventListener('click', event => {
 	updateDots(currentDot, targetDot);
 	hideShowArrows(targetIndex);
 })
-```
+```

exercises/leetcode/amazon/copyListWithRandomPointer.js

@@ -35,7 +35,7 @@ const copyRandomList = head => {
         }
 
         if (visited.has(node)) {
-            visited.get(node);
+            return visited.get(node);
         }
 
         visited.set(node, new Node(node.val, node.next, node.random));

exercises/leetcode/cloneGraph.js

@@ -0,0 +1,41 @@
+/**
+ * Given a reference of a node in a connected undirected graph, 
+ * return a deep copy (clone) of the graph. 
+ * Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.
+ */
+/**
+ * // Definition for a Node.
+ * function Node(val,neighbors) {
+ *    this.val = val;
+ *    this.neighbors = neighbors;
+ * };
+ */
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const visited = new Map();
+const cloneGraph = node => {
+    if (node === null) {
+        return node;
+    }
+
+    if (visited.has(node)) {
+        return visited.get(node);
+    }
+
+    let cloneNode = new Node(node, []);
+    visited.put(node, cloneNode);
+
+    for (let neighbor of node.neighbors) {
+        cloneNode.neighbors.push(cloneGraph(neighbor));
+    }
+
+    return cloneNode;
+}
+
+/**
+ * Time Complexity: O(N) (As we process each node once)
+ * Space Complexity: O(N) (Space taken by the map -> visited, and also the space taken up
+ * by the height of the recursion stack O(H))
+ */

exercises/leetcode/mergeKSortedList.js

@@ -0,0 +1,45 @@
+/**
+ * Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+
+Example:
+
+Input:
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+Output: 1->1->2->3->4->4->5->6
+ */
+/**
+ * Definition for singly-linked list. */
+ function ListNode(val) {
+    this.val = val;
+    this.next = null;
+ }
+
+
+const mergeKLists = lists => {
+    let head = new ListNode();
+    let point = head;
+    let nodes = [];
+
+    for (let l of lists) {
+        while (l) {
+            nodes.push(l.val);
+            l = l.next;
+        }
+    }
+    nodes.sort((a, b) => a - b);
+    for (let n of nodes) {
+        point.next = new ListNode(n);
+        point = point.next;
+    }
+
+    return head.next;
+}
+
+// Time Complexity: O (NlogN) => O(N) for looping list and creating array
+// O(NlogN) for sorting
+// O(N) for creating new list
+// Space Complexity: O(N)

exercises/linkedlist/sumLinkedList-II.js

@@ -0,0 +1,72 @@
+/**
+ * You are given two non-empty linked lists representing two non-negative integers. 
+ * The most significant digit comes first and each of their nodes contain a single digit. 
+ * Add the two numbers and return it as a linked list.
+ * You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+Follow up:
+What if you cannot modify the input lists? In other words, reversing the lists is not allowed.
+
+Example:
+
+Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 8 -> 0 -> 7
+ */
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = (l1, l2) => {
+    const s1 = [];
+    let node1 = l1;
+
+    while (node1) {
+        s1.push(node1);
+        node1 = node1.next;
+    }
+
+    const s2 = [];
+    let node2 = l2;
+
+    while (node2) {
+        s2.push(node2);
+        node2 = node2.next;
+    }
+
+    let carry = 0;
+    let prev = null;
+    let result = 0;
+
+    while (s1.length > 0 || s2.length > 0) {
+        let num1 = s1.length > 0 ? s1.pop().val : 0;
+        let num2 = s2.length > 0 ? s2.pop().val : 0;
+
+        result = num1 + num2 + carry;
+        if (result > 9) {
+            result = result - 10;
+            carry = 1;
+        } else {
+            carry = 0;
+        }
+
+        let curr = new ListNode(result);
+        curr.next = prev;
+        prev = curr;
+    }
+
+    if (carry) {
+        let curr = new ListNode(carry);
+        curr.next = prev;
+        prev = curr;
+    }
+
+    return prev;
+}

exercises/stacks&queues/queue.js

@@ -25,6 +25,6 @@ class Queue {
 
   // Return the last element in the queue without popping
   peek() {
-    return this.data[this.data.length - 1];
+    return this.data[0];
   }
 }