数组和双指针专题总结

一、概述

1、数组理论基础

数组是存放在连续内存空间上的相同类型数据的集合。

需要两点注意的是

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的

正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

二、题型

2.1 二分查找

2.1.1二分查找

704. 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

class Solution {
    public int search(int[] nums, int target) {
       int left=0,right=nums.length-1;
       while(left<=right)
       {
         int mid = (right+left)/2;
//int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
         if(nums[mid]<target)
            left=mid+1;
         else if(nums[mid]>target)
            right = mid-1;
         else
           return mid;      
       }

       return -1;
    }
}

2.2双指针

 2.2.1移除元素

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution {
    public int removeElement(int[] nums, int val) {
        int l = 0;
        for(int r =0;r<nums.length;++r){
            if(nums[r] != val){
                nums[l++] = nums[r];
            }
        }
        return l;
    }
}

2.2.2 删除有序数组中的重复项

26. 删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        int left= 1;
        int right = 1;
        while(right<nums.length){
            if(nums[right]!=nums[right-1]){
                nums[left++]=nums[right];
            }
            right++;
        }
        return left;
    }
}

2.2.3移动零

283. 移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意 ，必须在不复制数组的情况下原地对数组进行操作。

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

      }
      for(;j<nums.length;j++)
        nums[j]=0;
    }
}

2.2.4 比较含退格的字符串

844. 比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。注意：如果对空文本输入退格字符，文本继续为空。

class Solution {
    public boolean backspaceCompare(String s, String t) {
      
     return convert(s).equals(convert(t));
     
    }
   
    public String convert(String str)
    {
        StringBuffer string = new StringBuffer(); 

       for(int i=0;i<str.length();i++){
              if(str.charAt(i)!='#')
                 string.append(str.charAt(i));
              else if(string.length()>0)
                  string.deleteCharAt(string.length()-1);
                 
       }
       return string.toString();
    }

}

2.2.5 有序数组的平方

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

class Solution {
    public int[] sortedSquares(int[] nums) {
       int len= nums.length;
       int ans[] =new int[len];
       for(int i=0,j=len-1,pos=len-1;i<=j;){
               if(nums[i]*nums[i]<=nums[j]*nums[j])
               {
                        ans[pos--]=nums[j]*nums[j];
                        j--;
               }
              else
               {
                        ans[pos--]=nums[i]*nums[i];
                        i++;
               }

       }

     return ans;
    }
}

2.2.6三数之和

15. 三数之和

2.2.7三数之和

18. 四数之和

2.3.滑动窗口

2.3.1 长度最小子数组

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
    int result =Integer.MAX_VALUE;
    int start=0,end=0,sum=0;
    
    for(;end<nums.length;end++){
            sum=sum+nums[end];
       while(sum>=target){
               result = Math.min(result,end-start+1);
               sum-=nums[start++];
       }

    }
       
return result==Integer.MAX_VALUE?0:result;
    }
}

2.3.2 最小覆盖子串

76. 最小覆盖子串

2.3.3 水果成蓝