1.快慢指针
我们定义两个指针slow、fast。slow表示当前位置之前的元素都是不重复的，而fast则一直向后找，直到找到与slow位置不一样的 ，找到
之后就将slow向后移动一个位置，并将arr[fast]复制给arr[slow]，之后fast继续向后找，循环执行。找完之后slow以及之前的元素就都是
单一的了。这样就可以只用一轮移动解决问题。
2.对撞指针
对撞指针，有的地方叫做交换移除，核心思想是从右侧找到不是val的值来顶替左侧是val的值。什么意思呢？我们看图，我们以nums =
[0,1,2,2,3,0,4,2], val = 2为例：
3.原地移除所有数值等于 val 的元素
LeetCode27.给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。要求：不要使用
额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
例子1:
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
例子2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
(1)快慢指针
定义两个指针slow和fast，初始值都是0。Slow之前的位置都是有效部分，fast表示当前要访问的元素。遍历的时候，fast不断向后移动：
- 如果nums[fast]的值不为val，则将其移动到nums[slow++]处。
- 如果nums[fast]的值为val，则fast继续向前移动，slow先等待。
public static int removeElement(int[] nums, int val) {
int slow = 0;
for(int fast = 0;fast<nums.length;fast++){
if(nums[slow] != nums[fast]){
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
(2)对撞双指针
public static int removeElement(int[] nums, int val){
int right = nums.length - 1;
int left = 0;
for (left = 0; left <= right; ) {
if(nums[left] == val && nums[right] != val){
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
}
if(nums[left] != val){
left++;
}
if(nums[right] == val){
right--;
}
}
return left;
}
4.删除有序数组中的重复项
LeetCode26 给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。不要使用额
外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例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 。不需要考虑数组中超出新长度后面的元素。
实现
public static int removeDuplicates(int[] nums) {
//slow表示可以放入新元素的位置，索引为0的元素不用管
int slow = 1;
//循环起到了快指针的作用
for (int fast = 0; fast < nums.length; fast++) {
if (nums[fast] != nums[slow - 1]) {
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
拓展
上面这题既然重复元素可以保留一个，那我是否可以最多保留2个，3个或者K个呢？甚至一个都不要呢？
public static int removeDuplicates(int[] nums,int k) {
//slow表示可以放入新元素的位置，前k位元素不用管
int slow = k;
//循环起到了快指针的作用
for (int fast = k; fast < nums.length; fast++) {
if (nums[fast] != nums[slow - k]) {
nums[slow] = nums[fast];
slow++;
}
}
return slow;
}
5.元素奇偶移动专题
LeetCode905，按奇偶排序数组。给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。你
可以返回满足此条件的任何数组作为答案。
例如：
输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。
这个的解决方案可以采用上面的对撞双指针方法,比较的对象是奇数还是偶数
维护两个指针 left=0 和 right=arr.length-1，left从0开始逐个检查每个位置是否为偶数，如果是则跳过，如果是奇数则停下来。然后right
从右向左检查，如果是奇数则跳过偶数则停下来。然后交换array[left]和array[right]。之后再继续巡循环，直到left>=right。
public static int[] sortArrayByParity(int[] A) {
int left = 0, right = A.length - 1;
while (left < right) {
if (A[left] % 2 > A[right] % 2) {
int tmp = A[left];
A[left] = A[right];
A[right] = tmp;
}
if (A[left] % 2 == 0) left++;
if (A[right] % 2 == 1) right--;
}
return A;
}
6.数组轮转问题
LeetCode189.给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
例如：
输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
public static void main(String[] args) {
int[] arr = new int[]{2, 2, 2, 2, 3, 3, 3, 5, 5, 7, 8};
int k = 3;
int start = 0, end = arr.length - 1;
while (start < end) {
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
start++;
end--;
}
System.out.println(Arrays.toString(arr));
start = 0;
end = k - 1;
while (start < end) {
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
start++;
end--;
}
System.out.println(Arrays.toString(arr));
start = k;
end = arr.length - 1;
while (start < end) {
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
start++;
end--;
}
System.out.println(Arrays.toString(arr));
}
7.数组的区间专题
数组中表示的数据可能是连续的，也可能是不连续的，如果将连续的空间标记成一个区间，那么我们可以再造几道题，先看一个例子：
LeetCode228.给定一个无重复元素的有序整数数组nums。返回恰好覆盖数组中所有数字的最小有序区间范围列表。也就是说，nums 的
每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个范围但不属于 nums 的数字 x 。列表中的每个区间范围 [a,b] 应该按如下格
式输出：“a->b” ，如果 a != b"a" ，如果 a == b
示例1：
输入：nums = [0,1,2,4,5,7]
输出：["0->2","4->5","7"]
解释：区间范围是：
[0,2] --> "0->2"
[4,5] --> "4->5"
[7,7] --> "7"
示例2：
输入：nums = [0,2,3,4,6,8,9]
输出：["0","2->4","6","8->9"]
解释：区间范围是：
[0,0] --> "0"
[2,4] --> "2->4"
[6,6] --> "6"
[8,9] --> "8->9"
public static List<String> summaryRanges(int[] nums) {
List<String> res = new ArrayList<>();
// slow 初始指向第 1 个区间的起始位置
int slow = 0;
for (int fast = 0; fast < nums.length; fast++) {
// fast 向后遍历，直到不满足连续递增(即 nums[fast] + 1 != nums[fast + 1])
// 或者 fast 达到数组边界，则当前连续递增区间 [slow, fast] 遍历完毕，将其写入结果列表。
if (fast == nums.length - 1 || nums[fast] + 1 != nums[fast + 1]) {
// 将当前区间 [slow, fast] 写入结果列表
StringBuilder sb = new StringBuilder();
sb.append(nums[slow]);
if (slow != fast) {
sb.append("->").append(nums[fast]);
}
res.add(sb.toString());
// 将 slow 指向更新为 fast + 1，作为下一个区间的起始位置
slow = fast + 1;
}
}
return res;
}
拓展我们本着不嫌事大的原则，假如这里是要你在上面的情况反过来，找缺失的区间该怎么做呢？例如:
示例：
输入: nums = [0, 1, 3, 50, 75], lower = 0 和 upper = 99,
输出: ["2", "4->49", "51->74", "76->99"]
8.字符串替换空格问题
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
public String replaceSpace(StringBuffer str) {
String res="";
for(int i=0;i<str.length();i++){
char c=str.charAt(i);
if(c==' ')
res += "%20";
else
res += c;
}
return res;
}
102
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
