Java双指针专题——1.移动0 2.复写0 3.快乐数4.盛最多水的容器5.有效三角形的个数 6.和为s的两个数字7.三数之和8.四数之和

目录

1.移动0

2.复写0

3.快乐数

4.盛最多水的容器

5.有效三角形的个数 

6.和为s的两个数字

7.三数之和

8.四数之和

---

 

1.移动0

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

 

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:

输入: nums = [0]
输出: [0]

 

class Solution {
    public void moveZeroes(int[] array) {
         int index0=-1;
        for (int i = 0; i < array.length; i++) {
            if(array[i]!=0){
                if(index0!=-1){//（还没初始化）如果第一个0还没出现，那就不管现在出现的非0的数字
                //如果出现了那就交换这个数字和第一个出现0的位置                                             
                    int temp=array[i];
                    array[i]=array[index0];
                    array[index0]=temp;
                    index0++;
                }
            }
            else{//遍历到0，初始化第一个0出现的下标
                if(index0==-1){
                    index0=i;
                }
            }
        }
    }
}
//目标就是让0全部放在末尾

2.复写0

给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

 

示例 1：

输入：arr = [1,0,2,3,0,4,5,0]
输出：[1,0,0,2,3,0,0,4]
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]
示例 2：

输入：arr = [1,2,3]
输出：[1,2,3]
解释：调用函数后，输入的数组将被修改为：[1,2,3]

根据双指针的异地操作将他优化成原地操作。

变成原地的过程会发现，覆盖问题，根据“删除数组中值为val的元素”。 

class Solution {
    public void duplicateZeros(int[] arr) {
        int cur=0,dest=-1,n=arr.length;
        //1.找到最后一个需要腹泻的数字
        while(cur<n){
            if(arr[cur]==0) dest+=2;
            else dest+=1;
            if(dest>=n-1)  break;
            cur++;

        }
        //2.处理边界情况
        if(dest==n){
            arr[n-1]=0;
            cur--;
            dest-=2;
        }
        //3.从后向前完成复写
        while(cur>=0){
            if(arr[cur]!=0) {
                arr[dest--]=arr[cur--];
            }else{
                arr[dest--]=0;
                arr[dest--]=0;
                cur--;
            }
        }

    }
}

3.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

 

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

  

class Solution {
    public int bitSum(int n){
        int sum=0;
        while(n!=0){
            int t=n%10;
            sum+=t*t;
            n/=10;
        }
        return sum;
    }
    public boolean isHappy(int n) {
        int slow=n,fast=bitSum(n);
        while(slow!=fast){
            slow=bitSum(slow);
            fast=bitSum(bitSum(fast));
        }
        return slow==1;
    }
}

4.盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

 

示例 1：

 

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

class Solution {
    public int maxArea(int[] height) {
        int left=0,right=height.length-1,ret=0;
        while(left<right){
            int v=Math.min(height[left],height[right])*(right-left);
            ret=Math.max(ret,v);
            //左右两个值中相对小的移动；
            if(height[left]<height[right]) left++;
            else right--;
        }
        return ret;
    }
}

 

5.有效三角形的个数 

给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。

 

示例 1:

输入: nums = [2,2,3,4]
输出: 3
解释:有效的组合是: 
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3

暴力解

class Solution {
    public int triangleNumber(int[] nums) {
        Arrays.sort(nums);
        if(nums.length<3){
            return 0;
        }
        int count=0;
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                for(int k=j+1;k<nums.length;k++){
                    if(nums[j]+nums[i]>nums[k]){
                         count++;
                    }
                            
                 }
                
            }
        }
        return count;
    }
}

 

class Solution {
    public int triangleNumber(int[] nums) {
        //利用单调性的双指针
        //1.排序
        Arrays.sort(nums);
        //2.利用双指针；
        int ret=0,n=nums.length;
        for(int i=n-1;i>=2;i--){//固定最大的数
        //利用left,right指针统计符合要求的三元组的个数
             int left=0,right=i-1;
            while(left<right){
                if(nums[left]+nums[right]>nums[i]){
                    ret+=right-left;
                    right--;
                }else{
                    left++;
                }
            }

        }
        return ret;
    }
}

 

6.和为s的两个数字

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i = 0, j = nums.length - 1;
        while(i < j) {
            int s = nums[i] + nums[j];
            if(s < target) i++;
            else if(s > target) j--;
            else return new int[] { nums[i], nums[j] };
        }
        return new int[0];
    }
}

7.三数之和

 

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {

        List<List<Integer>> ret=new ArrayList<>();
        Arrays.sort(nums);
        int n=nums.length;
        for(int i=0;i<n;){
            if(nums[i]>0) break;//小优化
            int left=i+1,right=n-1,target=-nums[i];
            while(left<right){
                int sum=nums[left]+nums[right];
                if(sum>target) right--;
                else if(sum<target) left++;
                else{
                    ret.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[left],nums[right])));
                    left++;
                    right--;
                    //去重
                    while(left<right&&nums[left]==nums[left-1]) left++;
                    while(left<right&&nums[right]==nums[right+1]) right--;
                }
            }
            i++;
            while(i<n&&nums[i]==nums[i-1]) i++;
        }
        return ret;
    }
}

8.四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

 

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

 

排序+双指针 

 

 

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ret=new ArrayList<>();
        Arrays.sort(nums);
        int n=nums.length;
        for(int i=0;i<nums.length;){
            for(int j=i+1;j<nums.length;){
               int left=j+1,right=n-1;
               long aim=(long)target-nums[i]-nums[j];//最后看测试用例·然后改这里；
                while(left<right){
                    int sum=nums[left]+nums[right];
                    if(sum>aim) right--;
                    else if(sum<aim) left++;
                    else{
                       // ret.add(new ArrayList<Integer>(Arrays.asList(nums[i],nums[j],nums[left++],nums[right--])));
                        ret.add(Arrays.asList(nums[i],nums[j],nums[left++],nums[right--]));
                        //这两种我看都是可以的
                        //去重1
                        while(left<right&&nums[left]==nums[left-1]) left++;
                        while(left<right&&nums[right]==nums[right+1]) right--;

                    }

                }//去重2
                j++;
                while(j<n&&nums[j]==nums[j-1]) j++;
            }
            //去重3
            i++;
            while(i<n&&nums[i]==nums[i-1]) i++;
        }
        return ret;
    }
}