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;
}