add more solutions (up to #230)

Author: alexwawl

solutions/146_LRUCache.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number} capacity
+ */
+var LRUCache = function(capacity) {
+    this.capacity = capacity;
+    this.map = new Map();
+};
+
+/** 
+ * @param {number} key
+ * @return {number}
+ */
+LRUCache.prototype.get = function(key) {
+    let val = this.map.get(key)
+    if(val == undefined){return -1;}
+    //Map  has sorted order. FIFO.
+    this.map.delete(key);
+    //we get value and push it to the back;
+    this.map.set(key,val);
+    return val;
+};
+
+/** 
+ * @param {number} key 
+ * @param {number} value
+ * @return {void}
+ */
+LRUCache.prototype.put = function(key, value) {
+    //remove value if exists.
+    if(this.map.has(key)){
+        this.map.delete(key)
+    }
+    this.map.set(key,value);
+    let keys = this.map.keys();
+    while(this.map.size > this.capacity){
+        //remove  Least Recently Used  elements
+        this.map.delete(keys.next().value)
+    }
+};
+
+/** 
+ * Your LRUCache object will be instantiated and called as such:
+ * var obj = new LRUCache(capacity)
+ * var param_1 = obj.get(key)
+ * obj.put(key,value)
+ */

solutions/148_SortList.js

@@ -0,0 +1,62 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var sortList = function(head) {
+    function mergeSort(node){
+        if(!node || !node.next){
+            return node;
+        }
+        let middle = getMiddle(node);
+        let next_to_middle = middle.next;
+        //divide in the middle;
+        middle.next = null;
+        let left = mergeSort(node)
+        let right = mergeSort(next_to_middle);
+        let merged_list = merge(left,right);
+        return merged_list;
+    }
+    function merge(left,right){
+        let result = null
+        if(!left){
+            return right;
+        }
+        if(!right){
+            return left;
+        }
+        if(left.val<=right.val){
+            result = new ListNode(left.val);
+            result.next = merge(left.next,right)
+        } else{
+            result = new ListNode(right.val);
+            result.next = merge(left,right.next);
+        }
+        return result;
+    }
+    
+    function getMiddle(node){
+        if(!node){
+            return null
+        }
+        let slow = node;
+        let fast = node.next;
+        // fast are moving 2 times faster. so when it comes to the end,
+        // slow will be in the middle
+        while(fast!=null){
+            fast = fast.next;
+            if(fast!=null){
+                slow = slow.next;
+                fast = fast.next;
+            }
+        }
+        return slow;
+    }
+    return mergeSort(head)
+};

solutions/153_FindMinimuminRotatedSortedArray.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    let l_pointer = 0;
+    let r_pointer = nums.length-1;
+    while(l_pointer < r_pointer){
+        let half = l_pointer + Math.floor((r_pointer-l_pointer)/2)
+        if(nums[half] > nums[r_pointer]){
+            l_pointer = half + 1  
+        } else {
+            r_pointer = half
+        }
+    }
+    return nums[l_pointer]
+};

solutions/153_FindMinimuminRotatedSortedArray.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def findMin(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        l_pointer = 0
+        r_pointer = len(nums)-1
+        while l_pointer < r_pointer:
+            half = l_pointer + (r_pointer - l_pointer) // 2
+            if nums[half] > nums[r_pointer]:
+                l_pointer = half + 1
+            else:
+                r_pointer = half
+        
+        return nums[l_pointer]

solutions/160 _IntersectionofTwoLinkedLists.js

@@ -0,0 +1,60 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} headA
+ * @param {ListNode} headB
+ * @return {ListNode}
+ */
+var getIntersectionNode = function(headA, headB) {
+    let head1 = headA;
+    let head2 = headB;
+    let result = null;
+    
+    let count1 = getCount(head1);
+    let count2 = getCount(head2);
+    if(count1<count2){
+        let diff = count2-count1;
+        result = getIntersectionPoint(diff, head2, head1);
+    } else{
+        let diff = count1 - count2;
+        result = getIntersectionPoint(diff, head1, head2);
+    }
+    
+    function getIntersectionPoint(diff, bigger, smaller){
+        let current1 = bigger;
+        let current2 = smaller;
+        for(let i = 0; i<diff;i++){
+            if(!current1){
+                return null;
+            }
+            current1 = current1.next;
+        }
+        while(current1 && current2){
+            if(current1 === current2){
+                return current1
+            }
+            current1 = current1.next;
+            current2 = current2.next;
+        }
+        
+        return null;
+    }
+    
+    
+    function getCount(head){
+        let count = 0;
+        let curr = head;
+        while(curr){
+            count = count+1;
+            curr = curr.next;
+        }
+        return count;
+    }
+    return result;
+};

solutions/167_TwoSumII-Inputarrayissorted.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} numbers
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(numbers, target) {
+    let left = 0;
+    let right = numbers.length - 1;
+    let dict = {}
+    while(left<=right){
+        if(numbers[left]+numbers[right]===target){
+            return [left+1,right+1]
+        } else if(numbers[left]+numbers[right]<target){
+            left++
+        } else {
+            right--
+        }
+    }
+    return []
+};

solutions/173_BinarySearchTreeIterator.js

@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+var BSTIterator = function(root) {
+    function inorderTraversal(root){
+        if(root){
+            inorderTraversal(root.left)
+            _ordered_nodes.push(root.val);
+            inorderTraversal(root.right)
+        }
+    }
+    let _ordered_nodes = [];
+    inorderTraversal(root);
+    this.ordered_nodes = _ordered_nodes;
+    this.index = -1;
+};
+
+/**
+ * @return the next smallest number
+ * @return {number}
+ */
+BSTIterator.prototype.next = function() {
+    this.index = this.index+1;
+    return this.ordered_nodes[this.index]
+};
+
+/**
+ * @return whether we have a next smallest number
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasNext = function() {
+    return this.index+1 < this.ordered_nodes.length
+};
+
+/** 
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */

solutions/199_BinaryTreeRightSideView.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var rightSideView = function(root) {
+    var result = [];
+    var max_level = [0]
+    function helper(root, current_level, max_level){
+        if(root){
+            if(max_level[0] < current_level){
+                result.push(root.val);
+                max_level[0] = current_level
+            }
+            
+            // if right view : right -> left
+            // if left view : left -> right
+            helper(root.right,  current_level + 1, max_level)
+            helper(root.left,   current_level + 1, max_level)
+        }
+        
+    }
+    helper(root,1,max_level);
+    return result
+};

solutions/199_BinaryTreeRightSideView.py

@@ -0,0 +1,27 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def rightSideView(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        max_level = [0]
+        result = []
+        self.helper(root, max_level, 1, result)
+        return result
+        
+    def helper(self, root, max_level, current_level, result):
+        if root:
+            if max_level[0] < current_level:
+                result.append(root.val)
+                max_level[0] = current_level
+            
+            self.helper(root.right, max_level, current_level+1, result)
+            self.helper(root.left, max_level, current_level+1, result)
+                        

solutions/200_NumberofIslands.js

@@ -0,0 +1,26 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+var numIslands = function(grid) {
+    let count = 0;
+    function dfs(grid, i, j){
+        if(i<0 || i >= grid.length || j < 0 || j >=grid[0].length || grid[i][j] != '1'){
+            return;
+        }
+        grid[i][j] = '#' // mark as visited can be marked as 0 
+        dfs(grid,i+1,j);
+        dfs(grid,i-1,j);
+        dfs(grid,i,j+1);
+        dfs(grid,i,j-1);
+    }
+    for(let i = 0;i<grid.length;i++){
+        for(let j =0;j<grid[0].length;j++){
+            if(grid[i][j]=='1'){
+                dfs(grid,i,j)
+                count = count + 1
+            }
+        }
+    }
+    return count
+};

solutions/200_NumberofIslands.py

@@ -0,0 +1,23 @@
+class Solution(object):
+    def numIslands(self, grid):
+        """
+        :type grid: List[List[str]]
+        :rtype: int
+        """
+        result = 0
+        for i in range(len(grid)):
+            for j in range(len(grid[0])):
+                if grid[i][j] == '1':
+                    self.dfs(grid,i,j)
+                    result += 1
+        return result
+    
+    def dfs(self,grid,i,j):
+        if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] == '0':
+            return
+        
+        grid[i][j] = '0'
+        self.dfs(grid, i + 1, j)
+        self.dfs(grid, i-1, j)
+        self.dfs(grid, i, j+1)
+        self.dfs(grid, i , j-1)