27. 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
- 更改
nums数组，使nums的前k个元素包含不等于val的元素。nums的其余元素和nums的大小并不重要。 - 返回
k。
示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
提示：
-
0 <= nums.length <= 100 -
0 <= nums[i] <= 50 -
0 <= val <= 100
#include<stdio.h>
//暴力法
int searchInsert1(int* nums, int numsSize, int target)
{
int len = numsSize;
for (int i = 0; i < len; i++)
{
if (target == nums[i]) //// 发现需要移除的元素，就将数组集体向前移动一位
{
for (int j = i + 1 ;j < len; j++)
{
nums[j-1] = nums[j];
}
i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
len--; // 此时数组的大小-1
}
}
return len;
}
//双指针法
int searchInsert2(int* nums, int numsSize, int target)
{
int fast = 0,slow = 0;
for (fast = 0; fast < numsSize; fast++)
{
if(nums[fast] != target)
{
nums[slow++] = nums[fast];
}
}
return slow;
}
int main(int argc, char const *argv[])
{
int str[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int len = sizeof(str) / sizeof(0), target1 = 1,target2 = 3;
printf("去除%d后 元素的个数为%d\n", target1, searchInsert1(str, len, target1));
printf("去除%d后 元素的个数为%d\n", target2, searchInsert2(str, len,target2));
return 0;
}
59. 螺旋矩阵 II
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：
输入：n = 1
输出：[[1]]
提示：
1 <= n <= 20
#include <stdio.h>
#include <stdlib.h> // 包含标准库以使用 malloc 函数
int **generateMatrix(int n, int *returnSize, int **returnColumnSizes)
{
// 设置返回的矩阵大小
*returnSize = n;
*returnColumnSizes = (int *)malloc(sizeof(int) * n); // 为每行的列数信息分配内存
// 初始化返回结果数组ans
int **ans = (int **)malloc(sizeof(int *) * n); // 为矩阵的行指针分配内存
int i;
for (i = 0; i < n; i++)
{
ans[i] = (int *)malloc(sizeof(int) * n); // 为矩阵的每一行分配内存
(*returnColumnSizes)[i] = n; // 设置每一行的列数为 n
}
// 设置每次循环的起始位置
int startX = 0;
int startY = 0;
// 设置二维数组的中间值，若n为奇数。需要最后在中间填入数字
int mid = n / 2;
// 循环圈数
int loop = n / 2;
// 偏移数
int offset = 1;
// 当前要填入矩阵的数值
int count = 1;
while (loop)
{
int i = startX;
int j = startY;
// 模拟上侧从左到右
for (; j < startY + n - offset; j++) // 模拟上侧从左到右
ans[startX][j] = count++;
for (; i < startX + n - offset; i++) // 模拟右侧从上到下
ans[i][j] = count++;
for (; j > startY; j--) // 模拟下侧从右到左
ans[i][j] = count++;
for (; i > startX; i--) // 模拟左侧从下到上
ans[i][j] = count++;
// 偏移值每次加2
offset += 2;
// 遍历起始位置每次+1
startX++;
startY++;
loop--;
}
// 若n为奇数需要单独给矩阵中间赋值
if (n % 2)
ans[mid][mid] = count;
return ans;
}
// 打印矩阵的函数
void printMatrix(int **matrix, int n, int *returnColumnSizes)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < returnColumnSizes[i]; j++)
{
printf("%3d ", matrix[i][j]);
}
printf("\n");
}
}
int main()
{
int n = 5;
int returnSize;
int *returnColumnSizes;
// 生成矩阵
int **matrix = generateMatrix(n, &returnSize, &returnColumnSizes);
// 打印矩阵
printf("Generated %d x %d Spiral Matrix:\n", returnSize, returnSize);
printMatrix(matrix, n, returnColumnSizes);
// 释放内存
for (int i = 0; i < n; i++)
{
free(matrix[i]);
}
free(matrix);
free(returnColumnSizes);
return 0;
}
209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 子数组
[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
提示：
1 <= target <= 1091 <= nums.length <= 1051 <= nums[i] <= 105
#include<stdio.h>
#include<string.h>
#include<limits.h>
#define INT32_MAX 2147483647
#define INT32_MIN (-INT_MAX - 1)
//暴力法
int minSubArrayLen(int target, int* nums, int numsSize)
{
//初始化最小长度为INT_MAX
int minLength = INT32_MAX;
// 最终的结果
int sum = 0; // 子序列的数值之和
int subLength = 0; // 子序列的长度
int left, right;
for (left = 0; left < numsSize ; left++)
//每次遍历都清零sum，计算当前位置后和>=target的子数组的长度
{
sum = 0;
//从left开始，sum中添加元素
for (right = left ; right < numsSize ; right++)
{ // 设置子序列终止位置为j
sum += nums[right];
//若加入当前元素后，和大于target，则更新minLength
if (sum >= target)
{ // 一旦发现子序列和超过了target，更新result
subLength = right - left + 1; // 取子序列的长度
minLength = minLength < subLength ? minLength : subLength;
break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
}
}
}
//若minLength不为INT_MAX，则返回minLnegth
return minLength == INT32_MAX ? 0 : minLength;
}
//滑动窗口
int minSubArrayLen1(int target, int* nums, int numsSize)
{
//初始化最小长度为INT32_MAX
int minLength = INT32_MAX;
int sum = 0, left = 0, right = 0;
//右边界向右扩展
for ( ; right < numsSize; ++right)
{
sum += nums[right];
//当sum的值 >= target时,保存长度,并收缩左边界
while (sum >= target)
{
int subLength = right - left + 1; // 取子序列的长度
minLength = minLength < subLength ? minLength : subLength;
sum -= nums[left++];
}
}
//若minLength不为INT_MAX，则返回minLnegth
return minLength == INT32_MAX ? 0 : minLength;
}
int main(int argc, char const *argv[])
{
int str[] = {2,3,1,2,4,3};
int len = sizeof(str) / sizeof(str[0]), target = 7;
printf("1 target = %d的minLength为%d\n", target, minSubArrayLen(target, str, len));
for (int i = 0; i < len; i++)
{
printf("%d\t",str[i]);
}
int s[] = {1,1,1,1,1,1,1,1};
int len1 = sizeof(s) / sizeof(str[0]), target1 = 11;
printf("\n2 target = %d的minLength为%d\n", target1, minSubArrayLen1(target1, s, len1));
return 0;
}
704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
提示：
- 你可以假设
nums中的所有元素是不重复的。 n将在[1, 10000]之间。nums的每个元素都将在[-9999, 9999]之间。
#include <stdio.h>
#include <string.h>
//(版本一) 左闭右闭区间 [left, right]
int search1(int *nums, int numsSize, int target)
{
int left = 0;
int right = numsSize - 1;
int mid = 0;
while (left <= right)
{
mid = left + ((right - left) >> 1 );
if (nums[mid] > target)
{
right = mid - 1;
}
else if (nums[mid] < target)
{
left = mid + 1;
}
else
return mid;
}
return -1;
}
// (版本二) 左闭右开区间 [left, right)
int search2(int *nums, int numsSize, int target)
{
int left = 0;
int right = numsSize;
int mid = 0;
while (left < right)
{
mid = left + ((right - left) >> 1);
if (nums[mid] > target)
{
right = mid;
}
else if (nums[mid] < target)
{
left = mid + 1;
}
else
return mid;
}
return -1;
}
int main(int argc, char const *argv[])
{
int str[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int len = sizeof(str) / sizeof(0), target = 1;
printf("search1 target = %d的下标为%d\n", target, search1(str, len, target));
printf("search2 target = %d的下标为%d\n", target, search2(str, len, target));
return 0;
}
977. 有序数组的平方
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
提示：
1 <= nums.length <= 104-104 <= nums[i] <= 104nums已按 非递减顺序 排序
#include<stdio.h>
#include <stdlib.h>
#include<string.h>
int* sortedSquares(int* nums, int numsSize, int* returnSize)
{
//返回的数组大小就是原数组大小
*returnSize = numsSize;
//创建两个指针，right指向数组最后一位元素，left指向数组第一位元素
int k = numsSize - 1,left = 0;
//最后要返回的结果数组
int *result = (int*) malloc(sizeof(int) * numsSize);
int i , j;
for (i = 0, j = numsSize - 1; i <= j; )
{
//若左指针指向元素平方比右指针指向元素平方大，将左指针指向元素平方放入结果数组。左指针右移一位
if(nums[i]*nums[i] > nums[j]*nums[j])
{
result[k--] = nums[i]*nums[i];
i++;
}
else //若右指针指向元素平方比左指针指向元素平方大，将右指针指向元素平方放入结果数组。右指针左移一位
{
result[k--] = nums[j]*nums[j];
j--;
}
}
//返回结果数组
return result;
}
int main(int argc, char const *argv[])
{
int str[] = {-14, -8, 2, 0, 3, 5, 9, 11, 13};
int len = sizeof(str) / sizeof(0), target = 1;
int *p = sortedSquares(str,len,str);
for (int i = 0; i < len; i++)
{
printf("%d\t",p[i]);
}
return 0;
}
