Leetcode刷题笔记——数据结构(双指针/快慢指针)

1.两数之和 II - 输入有序数组

原题：

思路：
最开始的思路不是双指针，简单的想两轮循环判断和。

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for(int i=0;i<numbers.length;i++){
            for(int j=i+1;j<numbers.length;j++){
                if(numbers[i]+numbers[j]==target)
                    return new int[] {i+1,j+1};
            }
        }
        return null;

    }
    
}

双指针的思路：
一边循环，头尾相加判断和，和大于目标值，则尾往前移，若是和小于目标值，则头往后移

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

2.双指针之快慢指针

原题：

思路：
双指针，一个快指针指每个变动的元素，一个慢指针指不是val的值。
上代码：

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;

    }
}

3. 最大连续1的个数

原题：

思路： 这里也是考虑双指针，一个指针是用来正常的遍历每一个元素，另一个指针是用来记录开始为1的索引的位置。连续1的数即这两个指针的差。然后用变量max来记录最大的连续为1的个数。
需要注意的是：

• slow指针原始值的设置，设置为-1，方便计算（主要是考虑如果第一个数为1的情况）；二是为了下面这种情况
• 计算两个指针的差时，先要判断一下slow指针是不是不是-1，若不是-1，说明开始有1了。排除数组全是零的情况。
• 最后除了循环也要判断一下slow 的情况，这是考虑如果数组最后一个数也是1的情况。

上代码：

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int fast=0;
        int slow=-1;
        int max=0;
        for(;fast<nums.length;fast++){
            if(nums[fast]==1){
                if(slow==-1){
                    slow=fast;
                }
                
            }
            else{
                if(slow!=-1){
                    
                     max=Math.max(max,fast-slow);
                }
          
                     slow=-1;
                
            }
        }
        if(slow!=-1)
             max=Math.max(max,fast-slow);
        return max;

    }
}

4. 长度最小的子数组

原题

思路： 最先想到的是暴力破解，两遍循环，求和，然后判断一下是否大于等于s，并且用min储存最小长度。
PS：对min，还有max使用规范，初始化时
min=Integer.MAX_VALUE
max=Integer.MIN_VALUE
上代码：

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int sum;       
        int min=Integer.MAX_VALUE;
        boolean flag=false;
        for(int j=0;j<nums.length;j++){
            sum=nums[j];
            if(sum>=s)
                return 1;
          for(int i=j+1;i<nums.length;i++){
              sum+=nums[i];              
              if(sum>=s){
                  flag=true;
                  min=Math.min(min,i-j+1);                  
                  break;
            }
        }
            
        }
        if(flag==false)
            return 0;
     
        return min;

    }
}

其他解法：
队列法： 类似于滑动窗口。数据先进入队列，相加求和，如果和大于等于s，则先不进数据，并且依次将先进的数据移出，每次移出的时候判断和是否大于等于s，并用min记录下队列中的数据个数。等到和小于s，后面的数据再依次进入队列。并且，这里采用的是头指针和尾指针来控制。
上代码：

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int head=0;
        int wei=0;
        int sum=0;
        int min=Integer.MAX_VALUE;
        while(head<nums.length){
            sum+=nums[head];
            head++;            
            while(sum>=s){
                min=Math.min(min,head-wei);
                sum-=nums[wei];
                wei++;
            }
            
            }
         return min==Integer.MAX_VALUE?0:min;

        
       
    }
}

PS：return min==Integer.MAX_VALUE?0:min;
这一句可以直接判断min并返回。简练！

5.删除排序数组中的重复项

原题：

思路： 这里需要注意的是需要空间复杂度为O（1）。这里就排除了使用链表的可能。所以考虑使用快慢指针，用慢指针来指不重复的元素，用快指针来遍历。
上代码：

class Solution {
    public int removeDuplicates(int[] nums) {
        int i=0,j=0;
        while(j<nums.length){
            if(nums[i]==nums[j]){
                j++;
            }
            else{
                nums[++i]=nums[j];
                j++;
                
            }
        }
        return i+1;

    }
}

6.移动零

原题：

思路：又是在原数组上操作。所以考虑双指针。有两种思路

方法一：遍历一次

以快排的思想为基础，即考虑一个中间点，将数组中不为零的数放在中间点的左边，数组中的零放在中间点的右边，其中，中间点选为0。
其中，用慢指针记录零的位置，用快指针进行遍历。
上代码：

class Solution {
    public void moveZeroes(int[] nums) {
        int i=0;
        for(int j=0;j<nums.length;j++){
            if(nums[j]!=0){
                int tem=nums[j];
                nums[j]=nums[i];
                nums[i]=tem;
                i++;
            }
        }
    }
      
}

方法二 遍历两次

也是双指针，快慢指针的思路。
第一次遍历时，用快指针遍历，用慢指针记录非零的元素，即，在遍历的过程中，遇到不为零的数就往左移动。最终慢指针留存的是移动后，数组中不为零的最后一个元素的位置。
第二次遍历，从慢指针记录的下一个位置起，对数组中剩余的元素进行清零。
上代码：

class Solution {
	public void moveZeroes(int[] nums) {
		if(nums==null) {
			return;
		}
		//第一次遍历的时候，j指针记录非0的个数，只要是非0的统统都赋给nums[j]
		int j = 0;
		for(int i=0;i<nums.length;++i) {
			if(nums[i]!=0) {
				nums[j++] = nums[i];
			}
		}
		//非0元素统计完了，剩下的都是0了
		//所以第二次遍历把末尾的元素都赋为0即可
		for(int i=j;i<nums.length;++i) {
			nums[i] = 0;
		}
	}
}