118. 杨辉三角

关键：主要是确定输入的num和每行需要填充的数据对应数组的下标，输入num，对应num行最后一位下标是num-1；除了两头的1，中间需要填充的是1到num-2的值；
问题：第一次提交把等于0的情况漏掉了；
整个代码的时间复杂度是num+（1+。。+num-2）

杨辉三角

优化后

 var generate = function(numRows) {
    let arr=[]
    for(let i=1;i<=numRows; i++){
        let row = [];
        for(let j=0;j<i; j++){
            if(j==0 || j== i-1){
                row.push(1);
            }else{
                row.push(arr[i-2][j-1]+arr[i-2][j]);
            }
        }
        arr.push(row);
    }
    return arr;
};

优化后

977. 有序数组的平方

相当于用时间换空间

977.有序数组的平方

很明显for(var j=i-1;j>=0;j--)有序数组，这个遍历是可以优化的，目的是为了找到插入的位置，所以找到就退出，使用break；退出循环。时间和内存消耗都有所降低，但是总的来说是时间换空间，还能在循环遍历上进行优化。

优化后

var sortNumber = function(a, b) {
    return a-b;
}
var sortedSquares = function(A) {
    let B = [];
    for (let i = 0; i < A.length; i++) {
        B[i] = A[i] * A[i];
    }
    return B.sort(sortNumber);
};

采用lambda表达式最简单的写法

var sortedSquares = function(A) {
    return A.map(item=>(Math.pow(item,2))).sort((a,b)=>a-b);
};
or
var sortedSquares = function(A) {
    return A.map(i => i**2).sort((a,b) => a-b)
};

集中执行的结果比较

image.png

其中最后两次是同样的代码，但是执行时间和内存消耗都不相同，说明时间受网络影响很大，内存主要和比较的次数有关
然后我做了很多比较

执行用时 : 160 ms, 在Squares of a Sorted Array的C提交中击败了73.56% 的用户
内存消耗 : 21.8 MB, 在Squares of a Sorted Array的C提交中击败了71.97% 的用户

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int compare(const int* a,const int* b){
    return (*a - *b);
}
int* sortedSquares(int* A, int ASize, int* returnSize) {
    *returnSize = ASize;
    int* a = calloc(ASize,sizeof(int));
    for(int i = 0;i < ASize;i++)
        a[i] = A[i] * A[i];
    qsort(a,ASize,sizeof(int),compare);
    return a;
}

上面是数组是输入[-4,-1,0,3,10,3,20,15,35,22,1,13,55,33,26,64,52,11]，的C语言执行结果，效率和内存占用明显最优，我在考虑如果追求漂亮的数据我应该用C语言完成
因为测试数据在一个量级所以对性能的影响差别不大可以忽略，主要是代码质量、网络延迟及不同语言的效率。

image.png

896. 单调数列

var isMonotonic = function(A) {
    var isPure=true;    
    var isPure1=true;
    for(var i=0; i<A.length-1;i++){
        isPure &= A[i]<=A[i+1];
        isPure1 &=A[i]>=A[i+1];
    }
    return isPure || isPure1;
};

之前尝试写分支结构，怎么写都不太对，后来想后一个都大于前一个或者后一个都小于前一个，即全部都的逻辑，不正是逻辑与的目的吗，然后就大大的简化了代码，内存消耗很低。

867. 转置矩阵

/**
 * @param {number[][]} A
 * @return {number[][]}
 */
var transpose = function(A) {
    var tArray = new Array();  
    var row = A.length;
    var col = A[0].length;
    for(var k=0;k<col;k++){    
        tArray[k]=new Array();  
        for(var j=0;j<row;j++){   
            tArray[k][j]="";    
         }
    }
    
    for(var i=0; i<col;i++){
        for(var j=0; j<row;j++){
            tArray[i][j]=A[j][i];
        }
    }
    return tArray;
};

主要分为两块，一块定义二维数组，一块赋值