init

Author: zeyap

100.js

@@ -0,0 +1,9 @@
+var isSameTree = function(p, q) {
+    if(p === null && q=== null){return true;}
+    if(p===null||q===null){return false;}
+    if(p.val === q.val){
+        return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
+    }else{
+        return false;
+    }
+};

102.js

@@ -0,0 +1,17 @@
+var levelOrder = function(root) {
+    let res=[];
+    if(root===null)return res;
+    let stk=[{node:root, d:0}];
+    while(stk.length>0){
+        let curr = stk.shift();
+        res[curr.d] = res[curr.d]||[];
+        res[curr.d].push(curr.node.val);
+        if(curr.node.left!==null){
+            stk.push({node:curr.node.left,d:curr.d+1});
+        }
+        if(curr.node.right!==null){
+            stk.push({node:curr.node.right,d:curr.d+1});
+        }
+    }
+    return res;
+};

103.js

@@ -0,0 +1,20 @@
+var zigzagLevelOrder = function(root) {
+    if(root===null)return [];
+    let stk = [root];
+    let toRight = false;
+    let ans = [];
+    while(stk.length>0){
+        let levelNum = stk.length;
+        let level = [];
+        for(let i=0;i<levelNum;i++){
+            let curr = stk.shift();
+            level.push(curr.val);
+            if(curr.left)stk.push(curr.left);
+            if(curr.right)stk.push(curr.right);
+        }
+        if(toRight) level.reverse();
+        ans.push(level);
+        toRight = !toRight;
+    }
+    return ans;
+};

104.js

@@ -0,0 +1,32 @@
+// Depth first search
+
+var maxDepth = function(root) {
+     
+    var dfs = function(root){
+        if(root===null)return 0;
+        var leftDepth = 1+dfs(root.left);
+        var rightDepth = 1+dfs(root.right);
+        return leftDepth>rightDepth?leftDepth:rightDepth;
+    }
+    return dfs(root);
+};
+
+// Breath first search
+
+var maxDepth = function(root) {
+    if(root===null)return 0;
+    var q=[];
+    q.push(root);
+    var depth=0;
+    while(q.length!==0){
+        depth++;
+        var levelNum = q.length;
+        for(var i=0;i<levelNum;i++){
+            var currNode = q.shift();
+            if(currNode.left!==null)q.push(currNode.left);
+            if(currNode.right!==null)q.push(currNode.right);
+        }   
+    }
+    return depth;
+};
+

107.js

@@ -0,0 +1,36 @@
+//BFS
+
+var levelOrderBottom = function(root) {
+    if(root===null)return [];
+    let stk=[root];
+    let res=[];
+    let curr = root;
+    while(stk.length>0){
+        res.unshift(stk.map((item)=>item.val));
+        let levelNum = stk.length;
+        for(let i=0;i<levelNum;i++){
+            curr = stk.shift();
+            if(curr.left!==null)stk.push(curr.left);
+            if(curr.right!==null)stk.push(curr.right); 
+        }
+    }
+    return res;
+};
+
+//DFS
+
+var levelOrderBottom = function(root) {
+    if(root===null)return [];
+    let res=[];
+    DFS(root,0,res);
+    return res.reverse();
+};
+
+var DFS = function(root,level,res){
+    if(root===null)return;
+    res[level]=res[level]||[];
+    res[level].push(root.val);
+    DFS(root.left,level+1,res);
+    DFS(root.right,level+1,res);
+    return;
+}

108.js

@@ -0,0 +1,14 @@
+var sortedArrayToBST = function(nums) {
+    if(nums.length===0)return null;
+    return builder(nums,0, nums.length-1);
+};
+
+var builder = function(nums,lo,hi){
+    if(lo>hi)return null;
+    let mid = parseInt((lo+hi)/2);
+    let root=new TreeNode(nums[mid]);
+    root.val = nums[mid];
+    root.left=builder(nums,lo,mid-1);
+    root.right = builder(nums,mid+1,hi);
+    return root;
+}

11.js

@@ -0,0 +1,32 @@
+
+var maxArea = function(height) {
+    var maxar=0;
+    var head=0,tail=height.length-1;
+    var h,area;
+    while(head<tail){
+        area = Math.min(height[head],height[tail])*(tail-head);
+        if(area>maxar){
+            maxar = area;
+        }
+        h = Math.min(height[head],height[tail]);
+        while(height[head]<=h)head++;
+        while(height[tail]<=h)tail--;
+    }
+    
+    return maxar;
+};
+
+//========fastest======
+
+var maxArea = function(height) {
+    var maxar=0;
+    var head=0,tail=height.length-1;
+    var h,area;
+    while(head<tail){
+        maxar=Math.max(maxar,Math.min(height[head],height[tail])*(tail-head));
+        if(height[head]<height[tail]){head++;}
+        else{tail--;}
+    }
+    
+    return maxar;
+};

118.js

@@ -0,0 +1,13 @@
+var generate = function(numRows) {
+    let res = [];
+    for(let i=0;i<numRows;i++){
+        res[i]=[];
+        if(i===0){res[i]=[1];continue;}
+        for(let j=0;j<i+1;j++){
+            let x = res[i-1][j-1]||0;
+            let y = res[i-1][j]||0;
+            res[i][j] = x+y;
+        }
+    }
+    return res;
+};

119.js

@@ -0,0 +1,23 @@
+var getRow = function(rowIndex) {
+    let row = [];
+    for(let i=0;i<=rowIndex;i++){
+        let curr = [];
+        let rear= Math.floor(i/2);
+        let prevRear = i%2===0?rear-1:rear;
+        for(let j=0;j<=rear;j++){
+            if(j===0)curr[j]=1;
+            else if(j<=prevRear){
+                curr[j] = row[j-1]+row[j];
+            }else{
+                curr[j] = row[prevRear]*2;
+            }
+        }
+        row = curr;
+        curr = [];
+    }
+    let rev=[];
+    for(let i=row.length-1;i>=0;i--){
+        rev[row.length-1-i] = row[i];
+    }
+    return rowIndex%2===0?row.concat(rev.slice(1)):row.concat(rev);
+};

121.js

@@ -0,0 +1,31 @@
+// One pass
+var maxProfit = function(prices) {
+    let lowestPrice=Number.MAX_VALUE,maxProfit=0;
+    for(let i=0;i<prices.length;i++){
+        if(prices[i]<lowestPrice){
+            lowestPrice = prices[i];
+        }else{
+            let profit = prices[i]-lowestPrice;
+            if(profit>maxProfit){
+                maxProfit = profit;
+            }
+        }
+    }
+    return maxProfit;
+};
+
+// Kadane's algorithm
+var maxProfit = function(prices) {
+    let diffs=prices.map((price,id)=>{
+        if(id===0)return 0;
+        else return price-prices[id-1];
+    })
+    let maxProfit=0;
+    let maxSoFar=0;
+    for(let i=0;i<diffs.length;i++){
+        maxProfit=diffs[i]>maxProfit+diffs[i]?diffs[i]:maxProfit+diffs[i];
+        maxSoFar=(maxProfit>maxSoFar)?maxProfit:maxSoFar;
+    }
+    return maxSoFar;
+};
+