数值oj题:
1.移除元素：
原理思路：
这道题可以用双指针的思路来解决，快指针和慢指针来遍历数组，当快指针遇到不等于val的元素时，就把它复制到慢指针的位置，并且同时递增两个指针，当快指针遇到等于val的元素时，就跳过它，继续向后移动。最后慢指针的位置就是移除后数组的新长度，而且数组前面的元素都不等于val。
原理过程图如下：
图解示例：
示例一：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例二：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
代码实现:
int removeElement(int* nums, int numsSize, int val){
int dst = 0; // 定义一个慢指针，表示新数组的长度
int src = 0; // 定义一个快指针，表示原数组的遍历位置
while(src != numsSize) // 当快指针没有到达数组末尾时
{
if(nums[src] != val) // 如果当前元素不等于val
{
nums[dst] = nums[src]; // 就把它复制到慢指针的位置
dst++; // 慢指针递增
src++; // 快指针递增
}
else // 如果当前元素等于val
{
src++; // 快指针递增，跳过该元素
}
}
return dst; // 返回新数组的长度
}
2.删除有序数组中的重复项：
原理思路：
是上一道题的升级版。首先利用数组的升序排列特点，用两个指针（prev和cur）从前往后扫描数组，如果发现两个指针指向的元素不相等，说明是一个唯一的元素，就把它复制到另一个指针（dst）指向的位置，然后三个指针都向后移动一位。如果发现两个指针指向的元素相等，说明是一个重复的元素，就跳过它，只移动前两个指针。这样就可以在原地删除重复的元素，同时保持元素的相对顺序不变。最后返回dst指针的值，就是新数组的长度。并且满足时间复杂度是O(n)，空间复杂度是O(1)。
图解示例：
示例一：
输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例二：
输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
代码实现:
int removeDuplicates(int* nums, int numsSize){
//如果数组长度为0，直接返回0，经典错误
if(numsSize == 0)
{
return 0;
}
int dst = 0, cur = 1, prev = 0;
// 用一个循环遍历数组，直到当前位置到达数组末尾
while(cur < numsSize)
{
if(nums[prev] != nums[cur])
{
nums[dst] = nums[prev];
prev++;
cur++;
dst++;
}
else
{
prev++;
cur++;
}
}
nums[dst] = nums[prev]; // 循环结束后，把最后一个元素复制到目标位置
dst++;// 目标位置加一，得到新数组的长度
return dst;
}
3.数组形式的整数加法 ：
这一题需要考虑的点比较多，来逐一击破，下面是题目：
示例一：
输入：num = [1,2,0,0], k = 34
输出：[1,2,3,4]
解释：1200 + 34 = 1234
示例二：
输入：num = [2,7,4], k = 181
输出：[4,5,5]
解释：274 + 181 = 455
示例三：
输入：num = [2,1,5], k = 806
输出：[1,0,2,1]
解释：215 + 806 = 1021
原理思路：
int* addToArrayForm(int* num, int numSize, int k, int* returnSize){
1.动态分配retArr数组
首先，计算 k 的位数，用一个变量 kSize 存储。这是为了确定结果数组的最大长度。
然后，比较 num 和 k 的位数，取较大者作为结果数组的初始长度 len。动态分配一个长度为 len + 1 的整型数组 retArr，用来存储结果。多出的一位是为了防止最高位有进位的情况。
int kSize = 0; //存储 k 的位数
//134
int kNum = k;
while(kNum)
{
kSize++;
kNum /= 10;
}
int len = numSize > kSize ? numSize : kSize;//定义一个变量 len，用来存储 num 和 k 中较大的位数
int* retArr = (int*)malloc(sizeof(int)*(len + 1));
2.相加后的结果赋给retArr数组
接着，从低位到高位逐位相加 num 和 k。用一个变量 Ni 表示 num 数组的当前元素的下标，初始值为 numSize - 1。用一个变量 reti 表示 retArr 数组的当前元素的下标，初始值为 0。用一个变量 nextNum 表示进位，初始值为 0。循环 len 次，每次循环执行以下操作：
取出 num 数组的当前元素的值 n，如果 num 数组已经没有元素，则 n 为 0。
将 n、k 的最低位和进位 nextNum 相加，得到 ret。
如果 ret 大于 9，则说明有进位，将 ret 减去 10，得到个位数，并将 nextNum 设为 1。
如果 ret 不大于 9，则说明没有进位，将 nextNum 设为 0。
将 ret 存入 retArr 数组的当前位置。
将 num 数组的下标 Ni 减一，将 retArr 数组的下标 reti 加一，将 k 除以 10，去掉最低位。
int Ni = numSize - 1; //定义一个变量 Ni，用来表示 num 数组的最后一个元素的下标
int reti = 0; //定义一个变量 reti，用来表示 retArr 数组的当前元素的下标
int nextNum = 0; //定义一个变量 nextNum，用来存储进位
while(len--) //循环 len 次，从低位到高位逐位相加 num 和 k
{
int n = 0; //定义一个变量 n，用来存储 num 数组的当前元素的值
if(Ni >= 0) //如果 num 数组还有元素未处理
{
n = num[Ni]; //取出 num 数组的当前元素的值
Ni--; //num 数组的下标减一
}
int ret = n + k % 10 + nextNum; //将 num 数组的当前元素、k 的当前位和进位相加，得到 ret
k /= 10; //k 除以 10，去掉最低位
if(ret > 9) //如果 ret 大于 9，说明有进位
{
ret -= 10; //ret 减去 10，得到个位数
nextNum = 1; //进位设为 1
}
else //如果 ret 不大于 9，说明没有进位
{
nextNum = 0; //进位设为 0
}
retArr[reti] = ret; //将 ret 存入 retArr 数组的当前位置
reti++; //retArr 数组的下标加一
}
3.判断最高位相加后有没有进1
然后，检查最后是否还有进位。如果 nextNum 等于 1，则说明最高位有进位，将 1 存入 retArr 数组的最后位置，并将 reti 加一。例如：999+1 如果没有这段代码得出的会是000.
if(nextNum == 1) //如果最后还有进位
{
retArr[reti] = 1; //将进位存入 retArr 数组的最后位置
reti++; //retArr 数组的下标加一
}
4.反转数组
因为从低位到高位相加后存储是从新数组的低位到高位的，想要得到最后答案，还需要把数组反转。用两个变量 left 和 right 表示 retArr 数组的首尾元素的下标，初始值分别为 0 和 reti - 1。循环交换 left 和 right 所指向的元素，直到 left 不小于 right。
int left = 0, right = reti - 1; //定义两个变量 left 和 right，分别表示 retArr 数组的首尾元素的下标
while(left < right) //循环交换 retArr 数组的首尾元素，直到 left 不小于 right
{
int tmp = retArr[left]; //定义一个变量 tmp，用来暂存 retArr 数组的首元素的值
retArr[left] = retArr[right]; //将 retArr 数组的尾元素赋值给首元素
retArr[right] = tmp; //将 tmp 赋值给尾元素
left++; //left 加一，向右移动一位
right--; //right 减一，向左移动一位
}
*returnSize = reti; //将 reti 赋值给 returnSize 指针指向的变量，表示结果数组的长度
return retArr; //返回结果数组的指针
最后代码实现:
int* addToArrayForm(int* num, int numSize, int k, int* returnSize){
int kSize = 0;
//134
int kNum = k;
while(kNum)
{
kSize++;
kNum /= 10;
}
int len = numSize > kSize ? numSize : kSize;
int* retArr = (int*)malloc(sizeof(int)*(len + 1));
//num[] k
int Ni = numSize - 1;
int reti = 0;
int nextNum = 0; //进位
while(len--)
{
int n = 0;
if(Ni >= 0)
{
n = num[Ni];
Ni--;
}
int ret = n + k % 10 + nextNum;
k /= 10;
if(ret > 9)
{
ret -= 10;
nextNum = 1;
}
else
{
nextNum = 0;
}
retArr[reti] = ret;
reti++;
}
if(nextNum == 1)
{
retArr[reti] = 1;
reti++;
}
//转置
int left = 0, right = reti - 1;
while(left < right)
{
int tmp = retArr[left];
retArr[left] = retArr[right];
retArr[right] = tmp;
left++;
right--;
}
*returnSize = reti;
return retArr;
}
扫一扫
1238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
