目录
1.移除元素
题目：
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明：
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下：
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}示例 1：
输入：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]，也会被视作正确答案。
示例 2：
输入：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。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 100 0 <= nums[i] <= 50 0 <= val <= 100
答案：
解法一：暴力解法
class Solution {
public int removeElement(int[] nums, int val) {
int size=nums.length;
for(int i=0;i<size;i++){
if(nums[i]==val){
for(int j=i+1;j<size;j++){
nums[j-1]=nums[j];
}
size--;
//有多个连续的目标数字时，执行完if操作后第二个数字替换了第一个数字，要重新从原目标数字的位置开始遍历 判断替换后的数字是否也是目标数字
i--;
}
}
return size;
}
}解法二：双指针法
class Solution {
public int removeElement(int[] nums, int val) {
int fast;//快指针，指向原数组元素下标
int slow=0;//慢指针，指向删除元素后数组中剩下的元素的在新数组中的下标
for(fast=0;fast<nums.length;fast++){
if(nums[fast]!=val){//查找删除指定元素后剩下的元素
nums[slow]=nums[fast];
slow++;
}
}
return slow;
}
}2.删除有序数组中的重复项
地址：26. 删除有序数组中的重复项 - 力扣（LeetCode）
题目：
给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
判题标准:
系统会用下面的代码来测试你的题解:
int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案
int k = removeDuplicates(nums); // 调用
assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
assert nums[i] == expectedNums[i];
}如果所有断言都通过，那么您的题解将被通过。
示例 1：
输入：nums = [1,1,2] 输出：2, nums = [1,2,_] 解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 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 。不需要考虑数组中超出新长度后面的元素。
提示：
1 <= nums.length <= 3 * 104 -104 <= nums[i] <= 104 nums 已按 升序 排列
答案：
class Solution {
public int removeDuplicates(int[] nums) {
int fast;//快指针，指向原数组元素
int slow=1;//慢指针，指向删掉指定元素后的新数组元素下标
for(fast=0;fast<nums.length-1;fast++){
if(nums[fast+1]!=nums[fast]){
nums[slow]=nums[fast+1];
slow++;
}
}
return slow;
}
}3.移动零
题目：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12] 输出: [1,3,12,0,0]
示例 2:
输入: nums = [0] 输出: [0]
提示:
1 <= nums.length <= 104 -231 <= nums[i] <= 231 - 1
答案：
class Solution {
public void moveZeroes(int[] nums) {
int fast;
int slow=0;
if(nums.length>1){
for(fast=0;fast<nums.length;fast++){
if(nums[fast]!=0){
int index=nums[fast];
nums[fast]=0;
nums[slow]=index;
slow++;
}
}
}
}
}4.比较含退格的字符串
地址：844. 比较含退格的字符串 - 力扣（LeetCode）
题目：
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。
示例 1：
输入：s = "ab#c", t = "ad#c" 输出：true 解释：s 和 t 都会变成 "ac"。
示例 2：
输入：s = "ab##", t = "c#d#" 输出：true 解释：s 和 t 都会变成 ""。
示例 3：
输入：s = "a#c", t = "b" 输出：false 解释：s 会变成 "c"，但 t 仍然是 "b"。
提示：
1 <= s.length, t.length <= 200 s 和 t 只含有小写字母以及字符 '#'
进阶：
你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？
答案：
class Solution {
public boolean backspaceCompare(String s, String t) {
int i=s.length()-1,j=t.length()-1;//i、j分别为s、t遍历完后剩下的字符最后一个字符的下标 初始值为s、t最后一个字符的下标 从后往前遍历
int skipS=0,skipT=0;//字符串中"#"的数量
while(i>=0 || j>=0){//从后往前遍历s、t
while(i>=0){
if(s.charAt(i)=='#'){
skipS++;
i--;
}else if(skipS>0){
skipS--;
i--;
}else{
break;
}
}
while(j>=0){
if(t.charAt(j)=='#'){
skipT++;
j--;
}else if(skipT>0){
skipT--;
j--;
}else{
break;
}
}
if(i>=0 && j>=0){//s、t长度都大于0
if(s.charAt(i)!=t.charAt(j))//比较s、t最后一个字符是否相等
return false;
}else if((i<0 && j>=0) || (i>=0 && j<0)){//s、t有一个长度为0
return false;
}
i--;
j--;
}
return true;
}
}解题思路：比较含退格的字符串 - 比较含退格的字符串 - 力扣（LeetCode）
5.有序数组的平方
地址：977. 有序数组的平方 - 力扣（LeetCode）
题目：
给你一个按非递减顺序排序的整数数组 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] <= 104 nums 已按非递减顺序排序
答案：
class Solution {
public int[] sortedSquares(int[] nums) {
//因为新数组的最大值一定出现在原数组前后两端，所以只需要比较原数组两端的值平方并把更大的值放在新数组后面的位置即可
int size=nums.length;
int i;//从前往后遍历的指针
int j;//从后往前遍历的指针
int k=size-1;//新数组下标
int newNums[]=new int[size];
for(i=0,j=size-1;i<=j;){
if((nums[i]*nums[i])>=(nums[j]*nums[j])){
newNums[k]=nums[i]*nums[i];
i++;
}else{
newNums[k]=nums[j]*nums[j];
j--;
}
k--;
}
return newNums;
}
}
438
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
