@@ -1,8 +1,7 @@
 # Algorithms ToDo
 
-+ Valid Sudoku [LeetCode #36](https://leetcode.com/problems/valid-sudoku/)
-+ Regular Expression Matching [LeetCode #10](https://leetcode.com/problems/regular-expression-matching/)
-+ Letter Combination of a Phone Number [LeetCode #17](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)
-+ Generate Parentheses [LeetCode #22](https://leetcode.com/problems/generate-parentheses/)
-+ Combination Sum [LeetCode #39](https://leetcode.com/problems/combination-sum/)
-+ Wildcard Matching [LeetCode #44](https://leetcode.com/problems/wildcard-matching/)
++ Wildcard Matching [LeetCode #44](https://leetcode.com/problems/wildcard-matching/)
++ Permutations LeetCode #46
++ Permutations II LeetCode #47
++ Combinations LeetCode #77
++ Subsets LeetCode #78
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function(candidates, target) {
+    var result = [];
+
+    if (candidates == null || candidates.length === 0) { 
+        return result;
+    };
+ 
+    var current = [];
+    candidates.sort();
+ 
+    combinationSumHelper(candidates, target, 0, current, result);
+ 
+    return result;
+};
+
+function combinationSumHelper(candidates, target, j, curr, result){
+    if(target === 0){
+        var temp = curr.slice();
+        result.push(temp);
+        return;
+    }
+  
+    for(var i=j; i<candidates.length; i++){
+        if(target < candidates[i]) {
+            return;
+        }
+        curr.push(candidates[i]);
+        combinationSumHelper(candidates, target - candidates[i], i, curr, result);
+        curr.pop(); 
+    }
+ }
+
+const candidates = [2,3,6,7];
+const target = 7;
+console.log(combinationSum(candidates, target));
@@ -0,0 +1,48 @@
+/**
+ * @param {string} digits
+ * @return {string[]}
+ */
+var letterCombinations = function(digits) {
+  let sanitizeInput = function(unsanitizedDigits) {
+    let regex = /(\W|_|[0-1a-zA-Z])/g;
+    let sanitized = unsanitizedDigits.replace(regex, "");
+    return sanitized;
+  };
+  const mapping = {
+    2: ["a", "b", "c"],
+    3: ["d", "e", "f"],
+    4: ["g", "h", "i"],
+    5: ["j", "k", "l"],
+    6: ["m", "k", "o"],
+    7: ["p", "q", "r", "s"],
+    8: ["t", "u", "v"],
+    9: ["w", "x", "y", "z"],
+  };
+  let sanitizedDigits = sanitizeInput(digits);
+  if (sanitizedDigits.length > 12) {
+    return "1,388,674 combinations should be more than enough for you. Provide 12 or fewer digits.";
+  }
+  if (sanitizedDigits.length < 1) {
+    return "Nothing to return.";
+  }
+  let finalArray = [];
+
+  const backtrackRecursive = function(combination, nextDigits) {
+    if (nextDigits.length === 0) {
+      finalArray.push(combination);
+    } else {
+      for (let i = 0; i < mapping[nextDigits[0]].length; i += 1) {
+        backtrackRecursive(
+          combination + mapping[nextDigits[0]][i],
+          nextDigits.slice(1)
+        );
+      }
+    }
+  };
+
+  if (sanitizedDigits) {
+    backtrackRecursive("", sanitizedDigits);
+  }
+
+  return finalArray;
+};
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+const generateParenthesis = function(n) {
+    if (n === 0) {
+        return [""];
+    }
+    let result = [];
+    for (let i = 0; i < n; ++i) {
+        let lefts = generateParenthesis(i);
+        let rights = generateParenthesis(n - i - 1);
+
+        for (let l = 0; l < lefts.length; ++l) {
+            for (let r = 0; r < rights.length; ++r) {
+                result.push("(" + lefts[l] + ")" + rights[r]);
+            }
+        }
+    }
+    return result;
+};
+
+console.log(generateParenthesis(3));
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+
+var isMatch = function(s, p) {
+    if (p === "") return s === "";
+    var first_match = (s!="" && (p[0] == s[0] || p[0] == '.'));
+
+    if (p.length >= 2 && p[1] == '*'){
+        return (isMatch(s, p.substring(2)) ||
+                (first_match && isMatch(s.substring(1), p)));
+    } else {
+        return first_match && isMatch(s.substring(1), p.substring(1));
+    }
+};
@@ -1,5 +1,4 @@
 # Algorithms ToDo
 
 + avl tree
-+ basic binary tree
-+ binary search tree
++ basic binary tree
@@ -1,6 +1,5 @@
 # Algorithms ToDo
 
-+ linked list
 + double linked list
 + is palindrome
 + sqap nodes
 
@@ -0,0 +1,72 @@
+const node = require('./Node');
+let Node = node.Node;
+
+class LinkedList {
+    constructor() {
+        this.head = null;
+    }
+
+    append(data) {
+        if (this.head === null) {
+            this.head = new Node(data);
+            return;
+        }
+
+        let currentNode = this.head;
+
+        while (currentNode.next !== null) {
+            currentNode = currentNode.next;
+        }
+
+        currentNode.next = new Node(data);
+    }
+
+    prepend(data) {
+        const newHead = new Node(data);
+        newHead.next = this.head;
+        this.head = newHead;
+    }
+
+    deleteWithValue(key, value) {
+        if (this.head === null) return false;
+
+        if (this.head.data[key] === value) {
+            this.head = this.head.next;
+            return true;
+        }
+
+        let currentNode = this.head;
+
+        while (currentNode.next !== null) {
+            if (currentNode.next.data[key] === value) {
+                currentNode.next = currentNode.next.next;
+                return true;
+            }
+            currentNode = currentNode.next;
+        }
+
+        return false;
+    }
+
+    getNodeWithValue(key, value) {
+        if (this.head === null) return null;
+
+        let currentNode = this.head;
+
+        if (this.head.data[key] === value) {
+            return this.head;
+        }
+
+        while (currentNode !== null) {
+            if (currentNode.data[key] === value) {
+                return currentNode;
+            }
+
+            currentNode = currentNode.next;
+        }
+
+        return null;
+    }
+}
+
+module.exports = {LinkedList: LinkedList}
@@ -0,0 +1,97 @@
+const linked = require('./LinkedList');
+const node = require('./Node');
+let LinkedList = linked.LinkedList;
+let Node = node.Node;
+
+test('we can create a new linked list', () => {
+    const ll = new LinkedList();
+    expect(ll).toBeDefined();
+    expect(ll).toHaveProperty('head');
+});
+
+test('we can create a new node', () => {
+    const ll = new LinkedList();
+    const data = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const node = new Node(data);
+
+    expect(ll).toBeDefined();
+    expect(node.data).toEqual(data);
+});
+
+test('we can append to the linked list', () => {
+    const ll = new LinkedList();
+    const data = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const node = new Node(data);
+    ll.append(data);
+    expect(ll.head).toEqual(node);
+});
+
+test('we can prepend to the linked list', () => {
+    const ll = new LinkedList();
+    const firstData = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const secondData = {'repoName': 'jest', 'owner': 'facebook'};
+    const firstNode = new Node(firstData);
+    const secondNode = new Node(secondData);
+
+    ll.append(firstData);
+    ll.prepend(secondData);
+    secondNode.next = firstNode;
+
+    expect(ll.head).toEqual(secondNode)
+});
+
+test('we can delete from the linked list', () => {
+    const ll = new LinkedList();
+
+    const firstData = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const firstNode = new Node(firstData);
+
+    ll.append(firstData);
+    expect(ll.head).toEqual(firstNode);
+
+    ll.deleteWithValue('repoName', 'JavaScriptAlgorithms');
+
+    expect(ll.head).toEqual(null);
+});
+
+test('we receive false when trying to delete a non-existent node', () => {
+    const ll = new LinkedList();
+    expect (ll.deleteWithValue('repoName', 'nothing')).toBe(false);
+});
+
+test('we receive true when successfully deleting a node', () => {
+    const ll = new LinkedList();
+    const firstData = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+
+    ll.append(firstData);
+
+    expect (ll.deleteWithValue('repoName', 'JavaScriptAlgorithms')).toBe(true);
+});
+
+test('we can retrieve a node from the linked list', () => {
+    const ll = new LinkedList();
+
+    const firstData = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const secondData = {'repoName': 'jest', 'owner': 'facebook'};
+    const secondNode = new Node(secondData);
+
+    ll.append(firstData);
+    ll.append(secondData);
+
+    const fb = ll.getNodeWithValue('owner', 'facebook');
+
+    expect(fb).toEqual(secondNode);
+});
+
+test('we receive null when retreiving a non-existent node', () => {
+    const ll = new LinkedList();
+
+    const firstData = {'repoName': 'JavaScriptAlgorithms', 'owner': 'vJechsmayr'};
+    const firstNode = new Node(firstData);
+
+    ll.append(firstData);
+
+    const search = ll.getNodeWithValue('repoName', 'nothing');
+
+    expect(search).toBe(null);
+});
@@ -0,0 +1,8 @@
+class Node {
+    constructor (data) {
+        this.data = data;
+        this.next = null;
+    }
+}
+
+module.exports = {Node: Node}