Add week 2 solutions

Author: yolophg

invert-binary-tree/yolophg.js

@@ -0,0 +1,17 @@
+var invertTree = function(root) {
+    if (!root) return null;
+    
+    // swap left and right children.
+    let temp = root.left;
+    root.left = root.right;
+    root.right = temp;
+    
+    // recursively invert left and right subtrees.
+    invertTree(root.left);
+    invertTree(root.right);
+    
+    return root;
+};
+
+// Time complexity : O(n)
+// Space complexity : O(n)

linked-list-cycle/yolophg.js

@@ -0,0 +1,25 @@
+var hasCycle = function(head) {
+    // check to ensure that the head exists and if head is null or if there's only one, return false.
+    if (!head || !head.next) {
+       return false;
+   }
+
+   let slow = head;
+   let fast = head.next;
+
+   // iterates through the linked list looking for a cycle.
+   while (fast && fast.next) {
+       if (slow === fast) {
+           return true; 
+       }
+       // if the pointers haven't met yet, slow pointer moves one step forward.
+       slow = slow.next;
+       // fast pointer moves two steps forward.
+       fast = fast.next.next;
+   }
+
+   return false;
+};
+
+// Time complexity : O(n)
+// Space complexity : O(1)

merge-two-sorted-lists/yolophg.js

@@ -0,0 +1,30 @@
+var mergeTwoLists = function(list1, list2) {
+    // check if either of the input lists is null.
+    if (!list1) return list2;
+    if (!list2) return list1;
+
+    // create a dummy node.
+    let dummy = new ListNode();
+    let current = dummy;
+
+    // compare the values pointed to by list1 and list2.
+    while (list1 && list2) {
+        // append the smaller value to the merged list pointed to by current.
+        if (list1.val < list2.val) {
+            current.next = list1;
+            list1 = list1.next;
+        } else {
+            current.next = list2;
+            list2 = list2.next;
+        }
+        current = current.next;
+    }
+
+    // ensure any remaining nodes are appended.
+    current.next = list1 || list2;
+
+    return dummy.next;
+};
+
+// Time complexity : O(n+m)
+// Space complexity : O(1)

reverse-linked-list/yolophg.js

@@ -0,0 +1,21 @@
+var reverseList = function(head) {
+    let current = head;
+    let previous = null;
+
+    // iterates through the linked list nodes.
+    while(current){
+        // stores the next node of current.
+        const next = current.next;
+        // reverses the direction of the pointer of current to point to the previous node.
+        current.next = previous;
+        // updates previous to be the current node.
+        previous = current;
+        // moves current to the next node.
+        current = next;
+    }
+
+    return previous;
+};
+
+// Time complexity : O(n)
+// Space complexity : O(1)

valid-parentheses/yolophg.js

@@ -0,0 +1,32 @@
+var isValid = function(s) {
+    let array = [];
+
+    // loop and store elements in the char.
+     for(let i = 0; i < s.length; i++) {
+         let char = s[i];
+
+        // if it's opening one, push a closing one in stack array.
+         switch(char) {
+             case "(": array.push(")");
+             break;
+
+             case "{": array.push("}");
+             break;
+
+             case "[": array.push("]");
+             break;
+
+             default: 
+             // if it isn't opening one, pop last element and store it in the topElement.
+             let topElement = array.pop();
+             if(char !== topElement) {
+                 return false;
+             }
+         }
+     }
+    // check the length of array is zero.
+     return array.length === 0;
+};
+
+// Time complexity : O(n)
+// Space complexity : O(n)