[Algorithm]九章七：Two Pointer
604. Window Sum：点击打开链接
例如：[1,2,7,8,5], k=3
sum[0]=nums[0]+nums[1]+nums[2]=10
sum[1]=sum[0]-nums[0]+nums[0+3]=17，也就是说sum[1]=10-1+8
sum[2]=sum[1]-nums[1]+nums[1+3]=20，也就是说sum[2]=17-2+5
窗口向后滑动，要减去(滑出窗口里的值)，同时加上(滑入窗口里的值)
public class Solution {
/**
* @param nums a list of integers.
* @return the sum of the element inside the window at each moving.
*/
public int[] winSum(int[] nums, int k) {
if(nums==null || nums.length==0){
return new int[0];
}
if(k<=0){
return new int[0];
}
int[] sum=new int[nums.length-k+1];
for(int i=0;i539. Move Zeros：点击打开链接
public class Solution {
/**
* @param nums an integer array
* @return nothing, do this in-place
*/
public void moveZeroes(int[] nums) {
int j=0;
for(int i=0;ipublic class Solution {
/**
* @param nums an integer array
* @return nothing, do this in-place
*/
public void moveZeroes(int[] nums) { //为什么这种做法不行？
int j=nums.length; //i从头开始遍历，当值为0就和最后一个数交换位置，再有值为0，和最后一个的前一个交换
for(int i=0;i521.Remove Duplicates from Sorted Array：点击打开链接
public class Solution {
/**
* @param nums an array of integers
* @return the number of unique integers
*/
public int deduplication(int[] nums) { //例如：[1,3,1,4,4,2]
if(nums==null || nums.length==0){
return 0;
}
Arrays.sort(nums); //[1,1,1,2,3,4,4]
int index=1;
for(int i=1;i
public class Solution {
/**
* @param nums an array of integers
* @return the number of unique integers
*/
public int deduplication(int[] nums) { //方法二
if(nums==null || nums.length==0){
return 0;
}
Arrays.sort(nums); //解题前要看题目给出的数组是不是有序数组，不是的话要排序
int i=0; //是否排序也要看题目要求，如果让输出符合条件的索引，不可以排序
for(int n:nums){
if(i<1 || n!=nums[i-1]){
nums[i++]=n;
}
}
return i;
}
}101. Remove Duplicates from Sorted Array II：点击打开链接
思路：当i=0时，nums[0]还是本身
当i=1时，nums[1]也还是本身，因为不管nums[1]是否等于nums[0]都没关系，因为题目说最多可以有两个duplicates
从i=2开始，开始判断nums[i-2]!=n，也就是说nums[0]!=nums[2]，其实就是判断这个数与否等于它前两位的那个数，
如果不等于，符合题目要求，当前数有效，不移除。
public class Solution {
/**
* @param A: a array of integers
* @return : return an integer
*/
public int removeDuplicates(int[] nums) {
if(nums==null || nums.length==0){
return 0;
}
int i=0; //例如{3,3,4,5,5,6}
for(int n:nums){ //在i=0,i=1的时候已经和数组用n表示的前两个数比较过
if(i<2 || n!=nums[i-2]){ //i=2的时候，n!=nums[i-2]表示的是4!=nums[0]
nums[i++]=n;
}
}
return i;
}
}
8.Rotate String：点击打开链接
例如：char[] str=[a,b,c,d,e,f,g]，offset=3
Output: [e,f,g,a,b,c,d]
三步翻转法:
1. [g,f,e,d,c,b,a]，整个大翻转
2. [e,f,g,d,c,b,a]， e,f,g翻转
3. [e,f,g,a,b,c,d]， a,b,c,d翻转
注意：先整个大翻转的必要性，一般来说，由于往前放的位数少，因此先进行整个大翻转会省时
当然也可以先局部翻转，再整个大翻转
要看具体题目要求，是要在原来有序的数组上后面几个元素翻转到前面，还是已经翻转好的要恢复有序数组
也就是说，是要[a,b,c,d,e,f,g]->[e,f,g,a,b,c,d]，还是[e,f,g,a,b,c,d]恢复成[a,b,c,d,e,f,g]
public class Solution {
/**
* @param str: an array of char
* @param offset: an integer
* @return: nothing
*/
public void rotateString(char[] str, int offset) {
if(offset==0){
return;
}
if(str==null || str.length==0){
return;
}
int n=str.length;
offset=offset%n;
reverse(str,0,n-1);
reverse(str,0,offset-1);
reverse(str,offset,n-1);
}
private void reverse(char[] str,int start,int end){
while(start39.Recover Rotated Sorted Array ：点击打开链接
题意：这题就是要恢复成有序arraylist，例如：[4,5,1,2,3]->[1,2,3,4,5]
思路：从5和1这个位置入手，遍历整个list的值，只要前一个值比后一个值大，就找到了5和1，然后j进行三步翻转
注意：reverse方法对一个arraylist进行reverse，因此用了方法arraylist.set()
public class Solution {
/**
* @param nums: The rotated sorted array
* @return: void
*/
public void recoverRotatedSortedArray(ArrayList nums) {
if(nums==null || nums.size()==0){
return;
}
int k=0;
for(int i=0;inums.get(i+1)){
k=i;
reverse(nums,0,k);
reverse(nums,k+1,nums.size()-1);
reverse(nums,0,nums.size()-1);
}
}
}
private void reverse(ArrayList nums,int start,int end){
while(start 56.Two Sum：点击打开链接
下面就是经典题型Two Sum和它的一系列follow ups
对于Two Sum一般有两种做法：HashMap和Two Pointers
public class Solution {
/*
* @param numbers : An array of Integer
* @param target : target = numbers[index1] + numbers[index2]
* @return : [index1 + 1, index2 + 1] (index1 < index2)
*/
public int[] twoSum(int[] numbers, int target) { //HashMap方法
int[] result=new int[2];
if(numbers==null ||numbers.length==0){
return result;
}
Map map=new HashMap<>(); //例如:[2,7,11,15]，target=9
for(int i=0;i
map.put(numbers[i],i);
}else{ //往下遍历到nums[1]=7，map里有2，
result[0]=map.get(target-numbers[i])+1; //就把2和7所对应的索引加入到result list里
result[1]=i+1; //由于题目要求result不是zero-based，所以每个索引值+1
}
}
return result;
}
} 608.Two Sum-Input array is Sorted：点击打开链接
public class Solution {
/*
* @param nums an array of Integer
* @param target = nums[index1] + nums[index2]
* @return [index1 + 1, index2 + 1] (index1 < index2)
*/
public int[] twoSum(int[] nums, int target) { //双指针法：适合可以sort的数组
int[] result=new int[2];
if(nums==null || nums.length==0){
return result;
}
int start=0;
int end=nums.length-1;
while(starttarget){
end--;
}else{
result[0]=start+1; //注意好题目要求是non zero-based，还是zero-based
result[1]=end+1;
return result;
}
}
return null;
}
} 607.Two Sum-Data Structure Design：点击打开链接
public class TwoSum { //只能使用HashMap的
private List list=null;
private Map map=null;
public TwoSum(){
list=new ArrayList<>();
map=new HashMap<>();
}
// Add the number to an internal data structure.
public void add(int number) {
// Write your code here
if(!map.containsKey(number)){
map.put(number,1);
list.add(number);
}else{
map.put(number,map.get(number)+1);
}
}
// Find if there exists any pair of numbers which sum is equal to the value.
public boolean find(int value) {
for(int i=0;i1){
return true;
}
if(nums1!=nums2 && map.containsKey(nums2)){
return true;
}
}
return false;
}
}
// Your TwoSum object will be instantiated and called as such:
// TwoSum twoSum = new TwoSum();
// twoSum.add(number);
// twoSum.find(value);
587.Two Sum-Unique pairs：点击打开链接
public class Solution {
/**
* @param nums an array of integer
* @param target an integer
* @return an integer
*/
public int twoSum6(int[] nums, int target) {
if(nums==null || nums.length<0){
return 0;
}
Arrays.sort(nums);
int start=0,end=nums.length-1;
int count=0;
while(starttarget){
end--;
}else{
start++;
}
}
return count;
}
} 609. Two Sum-Less than or equal to target: 点击打开链接
例如：[2,7,11,15]，target=24
思路：当2+15<24，15是最大值都小于target了，2+7，2+11一定也小于，两数对应的索引相减3-0=3，这段区间有3对数符合要求，start++
再看[2,7,11,15]这段区间，同理有3-1=2对数符合要求，start++
再看[2,7,11,15]这段区间， 11+15>target，end--
public class Solution {
/**
* @param nums an array of integer
* @param target an integer
* @return an integer
*/
public int twoSum5(int[] nums, int target) {
if(nums==null || nums.length==0){
return 0;
}
Arrays.sort(nums);
int count=0;
int start=0,end=nums.length-1;
while(start443.Two Sum-Greater than target：点击打开链接
public class Solution {
/**
* @param nums: an array of integer
* @param target: an integer
* @return: an integer
*/
public int twoSum2(int[] nums, int target) { //和小于等于target的正好相反
if(nums==null ||nums.length==0){
return 0;
}
Arrays.sort(nums);
int count=0;
int start=0,end=nums.length-1;
while(start610.Two Sum-Difference equals to target：点击打开链接
例如：[2,7,15,14]，target=5
思路：遍历数组，但是每个值都要查看nums[i]+target和nums[i]-target 两种情况
public class Solution {
/*
* @param nums an array of Integer
* @param target an integer
* @return [index1 + 1, index2 + 1] (index1 < index2)
*/
public int[] twoSum7(int[] nums, int target) {
int[] result=new int[2];
if(nums==null || nums.length==0){
return result;
}
Map map=new HashMap<>();
for(int i=0;i 57. 3Sum：点击打开链接
例如：[-1,0,1,2,-1,-4]
思路：a+b+c=0，-a=b+c
遍历数组里的每一个数nums[i]，对于每一个数，都从i+1~nums.length-1区间来找另外两个数，
使得-nums[i]=nums[i+1]+nums[nums.length-1]，也就是nums[i]+nums[i+1]+nums[nums.length-1]=0
注意：1. 用Two Pointers方法一定要先Arrays.sort()数组
2. 对于nums[i]，nums[i+1]和nums[length-1]都要判断是不是与前一个数相等
public class Solution {
/**
* @param numbers : Give an array numbers of n integer
* @return : Find all unique triplets in the array which gives the sum of zero.
*/
public ArrayList> threeSum(int[] numbers) {
ArrayList> result=new ArrayList<>();
if(numbers==null || numbers.length<3){ //只要numbers.length<3就不符合题意了
return result;
}
Arrays.sort(numbers);
for(int i=0;i0 && numbers[i]==numbers[i-1]){ //对于每一个a都要判断是不是和前一个相等
continue;
}
int target=-numbers[i];
int start=i+1;
int end=numbers.length-1;
twoSum(numbers,start,end,target,result);
}
return result;
}
private void twoSum(int[] nums,int start,int end,int target,ArrayList> result){
while(start list=new ArrayList<>();
list.add(-target);
list.add(nums[start]);
list.add(nums[end]);
result.add(list);
start++;
end--;
while(start
例如：[1,1,2,3,4,5,6]，target=9
1. i从0向后遍历
2. 第一轮i=0,start=1,end=6，因为开始小于9，所以start++到start=2，此时1+2+6=9，
完成装到result后，start和end还会移动，找其他满足条件的组合，以上是一个完整的第一轮，然后才开始第二轮
3. 第二轮i=1,start=1,end=6，此时1+2+6=9
因为被遍历的i与它前一个数相等，因此会以continue的方法跳出本次，因为这样的情况下会输出重复组合
4. 第三轮i=2
public class Solution {
/**
* @param numbers : Give an array numbers of n integer
* @return : Find all unique triplets in the array which gives the sum of zero.
*/
public ArrayList> threeSum(int[] numbers) { //方法二：直接看当前三个数的和是不是等于0
ArrayList> result=new ArrayList<>(); //个人感觉这个方法更直接，更容易弄懂
if(numbers==null || numbers.length<3){
return result;
}
Arrays.sort(numbers);
for(int i=0;i0 && numbers[i]==numbers[i-1]){ //如果i重复
continue; //跳出本次i，进入for循环里的下一个i
}
int start=i+1;
int end=numbers.length-1;
while(start list=new ArrayList<>();
list.add(numbers[i]);
list.add(numbers[start]);
list.add(numbers[end]);
result.add(list);
start++;
end--;
while(start 923. 3Sum With Multiplicity
public int threeSumMulti(int[] A, int target) {
int mol = 1000000007; // 如果写成10^9+7的形式，就过不了，Bitwise Operators
Arrays.sort(A);
int res = 0;
Map map = new HashMap<>();
for (int i = 0; i < A.length; ++i) {
map.put(A[i], map.getOrDefault(A[i], 0l) + 1l);
}
for (int i = 0; i < A.length; i++) {
if (i > 0 && A[i] == A[i - 1])
{
continue;
}
int start = i + 1, end = A.length - 1;
while (start < end) {
if (A[i] + A[start] + A[end] < target) {
start++;
}
else if (A[i] + A[start] + A[end] > target) {
end--;
}
else {
if (A[i] == A[start] && A[start] == A[end]) {
res += (map.get(A[i])) * (map.get(A[i]) - 1) * (map.get(A[i]) - 2) / 6 % mol;
}
else if (A[i] == A[start]) {
res += (map.get(A[i])) * (map.get(A[i]) - 1) / 2 * (map.get(A[end])) % mol;
}
else if (A[start] == A[end]) {
res += (map.get(A[i])) * (map.get(A[start])) * (map.get(A[start]) - 1) / 2 % mol;
}
else {
res += map.get(A[i]) * map.get(A[start]) * map.get(A[end]) % mol;
}
start++;
end--;
while (start 259. 3Sum Smaller
Given an array of n integers nums and a target, find the number of index triplets i, j, k with 0 <= i < j < k < nthat satisfy the condition nums[i] + nums[j] + nums[k] < target.
Example:
Input: nums = [-2,0,1,3], and target = 2
Output: 2
Explanation: Because there are two triplets which sums are less than 2:
[-2,0,1]
[-2,0,3]
Note: 以[-2, 0, 1, 3]作为example , nums[i] =-2,，nums[start]=0,，nums[end]=3,，当-2+0+3 例如：[3,4,6,7]，Output:3 思路：sort数组后，i从后向前遍历数组，遍历的值nums[i]作为第三条边a，而nums[0]和nums[i-1]作为另两边b,c 因此如果满足b+c>a，就是一个三角形。 同时要注意，如果此时的b+c>a，得知(b后面的数)+c>a一定成立，所以直接加上这一段的有效三角形个数，然后end--; 如果b+c 注意：此题的遍历方向 思路：还是 Two Sum双指针法，只是每次都要记录target与当前nums[start]+nums[end]的差值，并更新成最小的closet值，也就是最closet的。 思路：和3Sum想法一样，不同点在于循环遍历两个数，另外两个数一个是start，一个是end 注意：题目要求输出list里不能包括重复的小list，因此循环遍历的两个数分别要检查是不是和后面的数相等 例如：[3,2,2,1]，k=2，Output：1 思路：“两大阵营” 根据题意分阵营，左边都是小于k的数，右边都是大于k的数 相向双指针遍历数组，如果左边遍历到的数小于k就left++，如果右边遍历到的数大于k就right-- 如果不属于我方阵营就和一个不属于对方阵营的数交换位置 注意： 1.本题最后return the partitioning index，eg:the first index i nums[i] =k，因为每次left++可以保证return left的值就是题目所要求。 2.题目还要求如果所以元素都比k小，就要返回数组的长度，例如：[1,1,1,1]，k=2，Output:4 这种情况就是一直left++，当left=3时，仍然满足while(left<=right && nums[left] 思路：与上面的两大阵营稍有不同，这题是用同向双指针，因为是正负数间隔，所以哪个符合条件哪个指针+2 但是题目没有说明原数组正，负整数的个数，因此要先判断正负数的个数情况，哪个多哪个就作为index=0 3-way-partition问题 思路：1.由i遍历数组，leftPointer一直指向左边部分后一个数，rightPointer指向右边部分前一个数 2.如果当前nums[i]属于左边部分，nums[leftPointer]和nums[i]交换位置，使得leftPointer真正指向一个属于左边部分的数 然后leftPointer++，i++同步跟上 3.如果当前nums[i]属于中间部分，i++表示跳过，因为中间部分的元素就要留在中间 4.如果当前nums[i]属于右边部分，nums[rightPointer]和nums[i]交换位置，使得rightPointer真正指向一个属于右边部分的数 然后rightPointer--，此时，i不能同步++向后移，因为不知道被换的nums[rightPointer]是不是也属于右边部分， 所以还要从这个i位置开始看nums[i]属于哪个部分 注意：多跑几个例子就可以知道，i会比leftPointer走的快，所以即使交换后leftPointer指向的是左边阵营结束元素的下一个元素，也是i走过的元素，因此是1 rightPointer指向的是右边阵营结束元素的下一个元素，但是方rightPointer的走向是向左的 彩虹排序问题 : O(nlogk) 思路：先分成两分，再递归分 例如：[3,2,2,1,4]，k=4 先分成colorMid=(colorFrom+colorTo)/2=(1+4/)2=2，所以开始的两分是[2,2,1,3,4]，再递归分每一分[2,2,1]和[3,4] 也就是两分先有个大致顺序，再不断递归局部的顺序，直到整体完全有序。 注意：前面两个return； class Solution {
public int threeSumSmaller(int[] nums, int target) {
int result = 0;
if(nums==null || nums.length == 0)
{
return result;
}
Arrays.sort(nums);
for(int i=0; i382.Triangle Count：点击打开链接
public class Solution {
/**
* @param S: A list of integers
* @return: An integer
*/
public int triangleCount(int S[]) {
if(S==null || S.length<3){
return 0;
}
Arrays.sort(S);
int count=0;
for(int i=S.length-1;i>0;i--){ //数组从后往前倒着遍历
int start=0;
int end=i-1;
while(start533.Two Sum-Closet to target: 点击打开链接
public class Solution {
/**
* @param nums an integer array
* @param target an integer
* @return the difference between the sum and the target
*/
public int twoSumClosest(int[] nums, int target) {
if(nums==null || nums.length<0){
return 0;
}
Arrays.sort(nums);
int start=0,end=nums.length-1;
int closet=Integer.MAX_VALUE;
while(startpublic class Solution {
/**
* @param nums an integer array
* @param target an integer
* @return the difference between the sum and the target
*/
public int twoSumClosest(int[] nums, int target) { //或者用和3Sum Closet通用方法
if(nums==null || nums.length<0){
return 0;
}
Arrays.sort(nums);
int start=0,end=nums.length-1;
int closet=Integer.MAX_VALUE;
while(start59.3Sum Closet：点击打开链接
public class Solution {
/**
* @param numbers: Give an array numbers of n integer
* @param target : An integer
* @return : return the sum of the three integers, the sum closest target.
*/
public int threeSumClosest(int[] numbers, int target) {
if(numbers==null || numbers.length<3){
return 0;
}
Arrays.sort(numbers);
int sum=0;
int closet=Integer.MAX_VALUE;
for(int i=0;i58.4Sum：点击打开链接
public class Solution {
/**
* @param numbers : Give an array numbersbers of n integer
* @param target : you need to find four elements that's sum of target
* @return : Find all unique quadruplets in the array which gives the sum of
* zero.
*/
public ArrayList31. Partition Array：点击打开链接
public class Solution {
/**
*@param nums: The integer array you should partition
*@param k: As description
*return: The index after partition
*/
public int partitionArray(int[] nums, int k) {
if(nums==null || nums.length==0){
return 0;
}
int left=0;
int right=nums.length-1;
while(left<=right){
while(left<=right && nums[left]373.Partition Array by Odd and Even：点击打开链接
public class Solution {
/**
* @param nums: an array of integers
* @return: nothing
*/
public void partitionArray(int[] nums) {
if(nums==null || nums.length==0){
return;
}
int left=0;
int right=nums.length-1;
while(left<=right){ //根据题意分两大阵营
while(left<=right && nums[left]%2==1){ //奇数阵营
left++;
}
while(left<=right && nums[right]%2==0){ //偶数阵营
right--;
}
if(left<=right){
int temp=nums[left];
nums[left]=nums[right];
nums[right]=temp;
left++;
right--;
}
}
}
}49. Sort Letters by Case：点击打开链接
public class Solution {
/**
*@param chars: The letter array you should sort by Case
*@return: void
*/
public void sortLetters(char[] chars) {
if(chars==null || chars.length==0){
return;
}
int left=0;
int right=chars.length-1;
while(left<=right){
while(left<=right && chars[left]>='a' && chars[left]<='z'){ //小写字母阵营
left++;
}
while(left<=right && chars[right]>='A' && chars[right]<='Z'){ //大写字母阵营
right--;
}
if(left<=right){
char temp=chars[left];
chars[left]=chars[right];
chars[right]=temp;
left++;
right--;
}
}
}
}144.Interleaving Positive and Negtive：点击打开链接
class Solution {
/**
* @param A: An integer array.
* @return: void
*/
public void rerange(int[] A) {
int posNum = 0, negNum = 0;
for (int i = 0; i < A.length; i++) {
if (A[i] > 0) {
posNum++;
} else {
negNum++;
}
}
int posIndex = 1, negIndex = 0;
if (posNum > negNum) {
posIndex = 0;
negIndex = 1;
}
while (negIndex < A.length && posIndex < A.length) {
while (negIndex < A.length && A[negIndex] < 0) {
negIndex += 2;
}
while (posIndex < A.length && A[posIndex] > 0) {
posIndex += 2;
}
if (posIndex < A.length && negIndex < A.length) {
int tmp = A[posIndex];
A[posIndex] = A[negIndex];
A[negIndex] = tmp;
posIndex += 2;
negIndex += 2;
}
}
}
}148.Sort Colors：点击打开链接
class Solution {
/**
* @param nums: A list of integer which is 0, 1 or 2
* @return: nothing
*/
public void sortColors(int[] nums) {
if(nums==null || nums.length==0){
return;
}
int leftPointer=0;
int rightPointer=nums.length-1;
int i=0;
while(i<=rightPointer){
if(nums[i]==0){
swap(nums,i,leftPointer); //是0就被交换到1阵营
leftPointer++;
i++;
}else if(nums[i]==1){
i++; //是1就跳过
}else{
swap(nums,i,rightPointer); //是2就被交换到当前2阵营
rightPointer--;
}
}
}
private void swap(int[] nums,int i,int j){
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}625.Partition Array II：点击打开链接
public class Solution {
/**
* @param nums an integer array
* @param low an integer
* @param high an integer
* @return nothing
*/
public void partition2(int[] nums, int low, int high) {
if(nums==null || nums.length==0){
return;
}
int i=0;
int leftPointer=0;
int rightPointer=nums.length-1;
while(i<=rightPointer){
if(nums[i]143.Sort Colors II：点击打开链接
class Solution {
/**
* @param colors: A list of integer
* @param k: An integer
* @return: nothing
*/
public void sortColors2(int[] colors, int k) {
if(colors==null || colors.length