LeetCode 12.6

102.二叉树的层序遍历

//递归，每一层的结点都放在对应索引的数组中。
var levelOrder = function(root) {
    let res = [];
    helper(res, root, 0);
    return res;
};
var helper = (arr, root, index) =>{
    if(root===null) return;
    if(arr[index]===undefined) arr[index]=[];
    arr[index].push(root.val);
    helper(arr, root.left, index+1);
    helper(arr, root.right, index+1);
}

108.将有序数组转换为二叉搜索树

//本质是二分法，注意是left>right时，才return null。
var sortedArrayToBST = function(nums) {
    return helper(nums, 0, nums.length-1);
};
var helper = (nums, left, right) =>{
    if(left>right) return null;
    let mid = Math.floor((left+right)/2);
    let root = new TreeNode(nums[mid]);
    root.left = helper(nums, left, mid-1);
    root.right = helper(nums, mid+1, right);
    return root;
}

40.爬楼梯

//数学归纳法？
var climbStairs = function(n) {
    let arr = [];
    arr[0] = 0;
    arr[1] = 1;
    arr[2] = 2;
    if(n<3) return arr[n];
    for(let i = 3; i<=n;i++){
        arr[i] = arr[i-1]+arr[i-2];
    }
    return arr[n];
};
//动态规划，好像没什么很大区别额。
var climbStairs = function(n) {
    let l=0;
    let m=0;
    let r=1;
    for(let i = 1;i<=n;i++){
        l=m;
        m=r;
        r=l+m;   
    }
    return r;
};

121.买卖股票的最佳时机

//动态规划？出现最大利润的两种前提，买入时是最低价格，买入不是最低价格但后面涨了足够多（就是最低价格出现在了最高价格之前。）
var maxProfit = function(prices) {
    if(prices.length===1) return 0;
    let profit = 0;
    let min = Number.MAX_SAFE_INTEGER;
    for(let i=0;i<prices.length;i++){
        min = min>prices[i]?prices[i]:min;
        pro = prices[i]-min;
        profit = pro>profit?pro:profit;
    }
    return profit;
};

53.最大子数组和

//动态规划
var maxSubArray = function(nums) {
    let pre = 0;
    let max = nums[0];
    for(let i of nums){
        pre = Math.max(pre+i,i);
        max = Math.max(pre,max);
    }
    return max;
};