leetcode学习第二次打卡

T66

int* plusOne(int* digits, int digitsSize, int* returnSize){
for(int i= digitsSize-1;i >= 0;i--)
{
    if(digits[i] != 9)
    {
        digits[i]++;
        break;
    }
    else digits[i] = 0;
}
if(digits[0] == 0)
{
    int *new;
    int new_size = digitsSize + 1;
    int k = new_size - 1;
    new = (int*)malloc(new_size*sizeof(int));
    while(k != 0)
    {
        new[k] = 0;
        k--;
    }
    new[k] = 1;
    *returnSize = new_size;
    return new;
}
else    
{   
    *returnSize = digitsSize;
    return digits;
}
}

T724

int pivotIndex(int* nums, int numsSize){
for(int i = 0;i < numsSize;i++)
{
    int left_sum = 0;
    int right_sum = 0;
    for(int j = i;j >= 0;j--)
    {
        left_sum += nums[j];
    }
    for(int k = i;k < numsSize;k++)
    {
        right_sum += nums[k];
    }
    if(left_sum == right_sum)
    {
        return i;
    }
}
return -1;
}

这种方法成功的把时间复杂度和空间复杂度都拉高了，所以需要换方法

这个方法最大的问题在于每一次都要重新找，导致之前做的所有工作都会被重复做多遍导致非常大的时间复杂度，于是在查找一些题解后发现了一种可以有效降低时间复杂度的方法——左右开弓。

int pivotIndex(int* nums, int numsSize){
    int left_sum = 0;
    int right_sum = 0;
    for(int i = 1;i < numsSize;i++)
    {
        right_sum += nums[i];
    }
    for(int i = 0;i < numsSize;i++)
    {
        if(right_sum == left_sum)return i;
        else
        {
            if(i != numsSize - 1)
            {
                right_sum -= nums[i+1];
                left_sum += nums[i];
            }
            else return right_sum == left_sum?numsSize - 1 : -1;
        }
    }
    return -1;
}

先对所有数求和，而这堆数都在右边，那么当数字位右移时，右边减一个元素，左边相应的增加一个，这样子就只需要一次循环就足够了。

T189

void rotate(int* nums, int numsSize, int k){
int temp;
for(int i = 1;i <= k;i++)
{
    temp = nums[numsSize-1];
    for(int j = numsSize-2;j >= 0;j--)
    {
        nums[j+1] = nums[j];
    }
    nums[0] = temp;
}
}

这样写肯定没有错，但是肯定也会爆，因为时间复杂度是O(n^2)，n往上就炸了，所以要改为相对合理的方法。

于是乎找到了一个牛的翻转法

如果有一串数 1 2 3 4 5 6 7想要完成翻转得到5 6 7 1 2 3 4

可以先全反转 7 6 5 4 3 2 1

然后k位截断（这里k = 3）7 6 5        4 3 2 1

然后分别翻转 5 6 7         1 2 3 4

组合起来 5 6 7 1 2 3 4

这个过程空间复杂度是O(1)，完全不用开新数组，帅爆

void swap(int *a,int *b)
{
    int t = *a;
    *a = *b;*b = t;
}
void reverse(int * nums,int start,int end)
{
    while(start < end)
    {
        swap(&nums[start],&nums[end]);
        start++;
        end--; 
    }
}
void rotate(int* nums, int numsSize, int k){
    k %= numsSize;
    reverse(nums,0,numsSize - 1);
    reverse(nums,0,k-1);
    reverse(nums,k,numsSize - 1); 
}

T48

void rotate(int** matrix, int matrixSize, int* matrixColSize){
int temp;
for(int i = 1;i <= matrixSize;i++)
{
    for(int j= 1;j<=matrixSize;j++)
    {
        if(i*2<=matrixSize+1 && j*2<=matrixSize)
        {
            temp = matrix[i-1][j-1];
            matrix[i-1][j-1] = matrix[matrixSize-j][i-1];
            matrix[matrixSize-j][i-1] = matrix[matrixSize-i][matrixSize-j];
            matrix[matrixSize-i][matrixSize-j]=matrix[j-1][matrixSize-i];
            matrix[j-1][matrixSize-i] = temp;
        }
    }
}
}

T54

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if(matrixSize==0||matrixColSize[0]==0){
        *returnSize=0;
        return NULL;
    }
    int m=matrixSize,n=matrixColSize[0];
    int*ret=(int*)malloc(sizeof(int)*(m*n));
    *returnSize=0;
    int left=0,right=n-1,top=0,bottom=m-1;
    while(left<=right&&top<=bottom){
        for(int x=left;x<=right;x++){
            ret[(*returnSize)++]=matrix[top][x];
        }
        for(int y=top+1;y<=bottom;y++){
            ret[(*returnSize)++]=matrix[y][right];
        }
        if(left<right&&top<bottom){
            for(int x=right-1;x>=left;x--){
                ret[(*returnSize)++]=matrix[bottom][x];
            }
            for(int y=bottom-1;y>top;y--){
                ret[(*returnSize)++]=matrix[y][left];
            }
        }
        left++;
        right--;
        top++;
        bottom--;
    }
    return ret;
}

T498

int* findDiagonalOrder(int** mat, int matSize, int* matColSize, int* returnSize){
int m = matSize,n = matColSize[0];
int *res = (int*)malloc(sizeof(int)*m*n);
int pos = 0;
for(int i = 0;i < m + n - 1;i++)
{
    if(i % 2)
    {
        int x = i < n ? 0:i - n + 1;
        int y = i < n ? i : n - 1;
        while(x < m && y >= 0)
        {
            res[pos] = mat[x][y];
            pos++;
            x++;
            y--;
        }
    }//斜下左下方
    else
    {
        int x = i < m ? i : m - 1;
        int y = i < m ? 0 : i - m + 1;
        while(x >= 0 && y < n)
        {
            res[pos] = mat[x][y];
            pos++;
            x--;
            y++;
        }
    }//斜上右上方
}
*returnSize = m * n;
return res;
}