26.删除排序数组中的重复项

int removeDuplicates(int* nums, int numsSize){
    if(numsSize==0){
        return 0;
    }
    int i = 0,j;
    for(j=1; j<numsSize; j++){
        if(nums[j]!=nums[i]){
            i++;
            nums[i] = nums[j];
        }
    }
    return i+1;
}

27.移除元素

int removeElement(int* nums, int numsSize, int val){
    int i = 0,j;
    for(j=0; j<numsSize; j++){
        if(nums[j]!=val){
            nums[i]=nums[j]; //nums[i]为新数组
            i++;
        }
    }
    return i;
}

53.最大子序和

int maxSubArray(int* nums, int numsSize){
    int subsum = 0, maxsum = -2147483648;
    
    for(int i = 0; i < numsSize; i ++)
    {
        subsum += nums[i];
        if(subsum > maxsum)
        {
            maxsum = subsum;
        }
        if(subsum < 0) subsum = 0;
    }
    return maxsum;
}

66.加一

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* plusOne(int* digits, int digitsSize, int* returnSize){
    if (digits == NULL && digitsSize == 0){ //传参检查
        *returnSize = 0;
        return NULL;
    }
    int flag = 0; //进位标志
    int i = digitsSize - 1; //数组下标
    int* res = (int*)malloc((digitsSize+1) * sizeof(int));
    //申请多一位空间（最高位产生进位）
    digits[i] = digits[i] + 1;//最低位 + 1

    //特别注意这里改变了源数据，这点不太好，值得改进
    for (; i >= 0; --i){
        res[i] = digits[i] + flag;
        if (res[i] >= 10){//判断有无进位
            res[i] = res[i]%10;
            flag = 1;
        }
        else{
            flag = 0;
        }
    }

    *returnSize = digitsSize + flag;
    if (flag != 0){ //最高位产生了进位
        int tmp;
        int mid = flag; //进位数 赋给 数组第一位（新的最高位）
        for (i = 0; i <= digitsSize; ++i){
            tmp = res[i]; //保存当前值
            res[i] = mid;
            mid = tmp; //移动至下一个位置
        }
    }
    return res;
}

88.合并两个有序数组

//由后向前排

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){

    int tag1=m-1;       //nums1最后一个元素数组下标
    int tag2=n-1;       //nums2最后一个元素数组下标
    int end=m+n-1;      //目标nums1处理下标
    while(end>-1){
        if(tag1<0){     //处理边界问题，防止nums[tag]数组越界
            nums1[end]=nums2[tag2];
            tag2--;
        }
        else if(tag2<0){
            nums1[end]=nums1[tag1];
            tag1--;
        }
        else if(nums1[tag1]>nums2[tag2]){
            nums1[end]=nums1[tag1];
            tag1--;
        }
        else{
            nums1[end]=nums2[tag2];
            tag2--;
        }
        end--;
    }
}

题解_Java

class Solution {
  public void merge(int[] nums1, int m, int[] nums2, int n) {
    System.arraycopy(nums2, 0, nums1, m, n); //将俩个数组合并
    Arrays.sort(nums1); //对合并后的新数组排序  缺点：没考虑俩个旧数组已经是有序的
  }
}

118.杨辉三角形

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** generate(int numRows, int* returnSize, int** returnColumnSizes){
    *returnSize = numRows;
    *returnColumnSizes = (int*)malloc(4*numRows);
    
    int i,j;
    int **ret = (int**)malloc(sizeof(int*)*numRows); //声明

    for(i=0; i<numRows; i++){
        (*returnColumnSizes)[i] = i+1; //初始化
        ret[i] = (int*)malloc(i*4+4);
        ret[i][0] = 1;
        ret[i][i] = 1;
    }

    for(i=2; i<numRows; i++){
        for(j=1; j<i; j++){
            ret[i][j] = ret[i-1][j-1] + ret[i-1][j]; //计算
        }
    }
    
    return ret;
}

119.杨辉三角形II

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
//申请一行的空间，从后往前处理就不需要考虑数组元素被处理时被覆盖的问题。

int* getRow(int rowIndex, int* returnSize){
    * returnSize = rowIndex + 1; //第k行有k个元素
    int* array = (int *)malloc(sizeof(int) * (rowIndex+1));
    for(int i=0; i<rowIndex+1; i++){
        array[i]=1; //行末尾为1
        for(int j=i-1; j>0; j--){ //每一行的更新过程
            array[j] = array[j] + array[j-1];
        }
        array[0] = 1;
    }
    return array;
}

717.1比特与2比特字符

/*方法一：线性扫描
我们可以对 \mathrm{bits}bits 数组从左到右扫描来判断最后一位是否为一比特字符。当扫描到第 ii 位时，如果 \mathrm{bits}[i]=1bits[i]=1，那么说明这是一个两比特字符，将 ii 的值增加 2。如果 \mathrm{bits}[i]=0bits[i]=0，那么说明这是一个一比特字符，将 ii 的值增加 1。

如果 ii 最终落在了 \mathrm{bits}.\mathrm{length}-1bits.length−1 的位置，那么说明最后一位一定是一比特字符。
*/

bool isOneBitCharacter(int* bits, int bitsSize){
    int i = 0;
    while(i<bitsSize-1){
        i += bits[i] + 1;
    }
    return i == bitsSize - 1;
}

989.数组形式的整数加法

/*思路

让我们逐位将数字加在一起。举一个例子，如果要计算 123123 与 912912 的和。我们顺次计算 3+23+2、2+12+1、1+91+9。任何时候，当加法的结果大于等于 1010，我们要将进位的 11 加入下一位的计算中去，所以最终结果等于 10351035。

算法

我们可以对以上的想法做一个小变化，让它实现起来更容易 —— 我们将整个加数加入数组表示的数的最低位。

继续之前的例子 123+912123+912，我们把它表示成 [1, 2, 3+912][1,2,3+912]。然后，我们计算 3+912 = 9153+912=915。55 留在当前这一位，将 910/10=91  以进位的形式加入下一位。

然后，我们再重复这个过程，计算 [1, 2+91, 5][1,2+91,5]。我们得到 9393，33 留在当前位，将0/10=9 以进位的形式加入下一位。继而又得到 [1+9, 3, 5][1+9,3,5]，重复这个过程之后，最终得到结果 [1, 0, 3, 5][1,0,3,5]。
*/
class Solution {
    public List<Integer> addToArrayForm(int[] A, int K) {
        int N = A.length;
        int cur = K;
        List<Integer> ans = new ArrayList();

        int i = N;
        while (--i >= 0 || cur > 0) {
            if (i >= 0)
                cur += A[i];
            ans.add(cur % 10);
            cur /= 10;
        }

        Collections.reverse(ans);
        return ans;
    }
}