双指针汇总（未完待续）

9. 回文数

力扣链接

思路：

法一：数字转字符串，从两边往中间遍历，进行字符比较，也就是双指针。
法二：通过除法、模运算，得到数字的每一位，存入数组，再用双指针。

 public boolean isPalindrome(int x) {
     String str =String.valueOf(x);
     int i = 0; 
     int j = str.length()-1;
     while(i <= j && str.charAt(i) == str.charAt(j)){
         i++;
         j--;
     }
     return i > j;
 }

//进阶--不转字符串
 public boolean isPalindrome(int x) {
     if(x < 0) return false;
     int[] rec = new int[11];
     int r = 0;//数字长度
     while(x != 0){
         rec[r++]=x%10;
         x/=10;
     }
     r--;
     int l = 0;        
     while(l <= r && rec[l] == rec[r]){ 
         l++;
         r--;
     };
     //while(l <= r && rec[l++] == rec[r--]){}; 错误写法  l++ r-- 两个rec不相等时也会执行，例如用例：12
     if(l > r) return true;
     return false;
 }

优化，取模的过程是从后往前遍历每个数，那么，如果同时用乘法，从后往前计算，得到的结果如果跟最初的值一样，说明是回文数，例如1221，反过来也是1221，但1231反过来是 1321。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0) return false;
        int tmp = x;
        int y = 0;
        while(tmp != 0){
            //乘法，获得x的倒数
            y = y * 10 + tmp % 10; 
            tmp = tmp / 10;
        }
        return x == y;
    }
}

5. 最长回文子串

力扣传送门

字符串中心扩展（双指针）
以字符为中心，不断向外扩展，比较左右是否相等，中间记录下最长串就行了。例如：aba
①遇到a，以a为中心，发现a左边越界，结束；
②遇到b，以b为中心，b的左右都不越界且相等，跟最大值（0）比较，大于则更新最大值，并记录串的位置，即start=0，end=2，继续扩展，发现越界，结束。
③遇到a，同理①。结果最大串为substring(start，end)
⚡️当然，我们还需要以两个字符为中心进行扩展。例如对于abba，如果以上面的例子，即一个字符为中心进行扩展，则结果为1，但实际结果为4

class Solution {
    public String longestPalindrome(String s) {
        //中心扩展
        int len = s.length();
        int start=0, end=0; //记录最大串的开始和结束下标
        int max=0; //记录最大的串
        for(int i=0; i<len; i++) {
            int l = i-1, r=i+1;
            //单数进行中心扩展---例如"ababa"
            while(l>=0 && r<len) {
                if(s.charAt(l) != s.charAt(r)) break;
                if(r-l>max) {
                    start=l;
                    end=r;
                    max=r-l;
                }
                l--;
                r++;
            }
            //双数进行中心扩展----例如"cbbd"
            l=i;
            r=i+1;
            while(l>=0 && r<len) {
                if(s.charAt(l) != s.charAt(r)) break;
                if(r-l>max) {
                    start=l;
                    end=r;
                    max=r-l;
                }
                l--;
                r++;
            }
        }
        return s.substring(start, end+1);
    }
}

优化：单数和双数的中心扩展代码可抽取为方法

647. 回文子串(计数)

统计回文字串的个数，做法类似求最长回文子串

力扣链接

思路：

法一：遍历每种长度的字符串，长度为1的，长度为2…从两边往中间，对左右字符进行比较，也就是双指针由两边往中间靠拢。（选出字符后判断）
法二：以当前字符为中心，比较两边的字符，也就是双指针由中间往两边扩张。其中以当前字符为中心需要考虑两种情况，单个字符和两个字符。否则会有缺漏，不像法一，虽然暴力，但每种请况都考虑到。
(根据判断来扩展字符)

 int ans = 0;
 public int countSubstrings(String s) {
     ans = s.length();
     //遍历每种长度的字符串
     for(int len = 1; len < s.length(); len++){
         int j= len;
         for(int i = 0;j < s.length(); i++,j++){
             judge(s,i,j);
         }
     }
     return ans;
 }
 //两边往中间
 public void judge(String s, int i, int j){
     while(i <= j && s.charAt(i) == s.charAt(j)) {
         i++;
         j--;
     }
     if(i > j) ans++;
 }
}

 private int count = 0;
 
 public int countSubstrings(String s) {
         
     for(int i = 0; i < s.length(); i++) {
         judge(s,i,i);//以单个为中心，最终串的长度为奇数
         judge(s,i,i+1);//以两个为中心，最终串为偶数长度
     }
     return count;
 }
 //从中间往两边移动双指针
 public void judge(String s, int left, int right) {
     int l = s.length();
     while(left >=0 &&  right < l && s.charAt(left) == s.charAt(right)) {
         count++;
         left--;
         right++;
     }
 }

696. 计数二进制子串

力扣链接

思路：

法一：若01符合 那就查看?01?是否符合，符合条件就是0左边的数是否等于0，且1右边的数是否等于1，可通过双指针，由内不断外扩，类似回文字符串。其中，内部串不成立，外部串就肯定不成立，这也是为什么能从内到外的原因。

 public int countBinarySubstrings(String s) {
     int l = s.length() - 1;
     int count = 0;
     for(int i=0; i < l; i++) {
         if(s.charAt(i) != s.charAt(i+1)) {
             count++;
             //双指针
             int left = i - 1, right = i + 2;
             while(left>=0 && right<=l) {
                 if(s.charAt(left) == s.charAt(i) && s.charAt(right) == s.charAt(i+1)) {
                     count++;
                 } else {
                     break;
                 }
                 left--;
                 right++;
             }
         }
     }
     return count;
 }

法二：从第一个字符开始，计算连续重复字符的个数tmp，直到出现转折的地方j， 往后与前面重复的数字不断比较，有多少个不一样的，就有多少个符合的字串，最多tmp个

    public int countBinarySubstrings(String s) {
        int ls = s.length() - 1;
        int ans = 0;    //符合的字串个数    
        for(int i = 0 ; i < ls ; i++) {
            //计算连续重复的个数
            int tmp = 1;  
            while(i < ls  && s.charAt(i) == s.charAt(i+1)) {
                tmp++;
                i++;
            }
            //转折点，往后与i进行比较，每不相等一个，ans就加一
            int j = i + 1;
            while(j <= ls && s.charAt(i) != s.charAt(j) && tmp > 0) {
                tmp--;
                ans++;
                j++;
            }
        }
        return ans;        
    }

思路三：就是0和1之间的个数取小的一边，例如001110 取2+1，00011000 取2+2

class Solution {
  
    public int countBinarySubstrings(String s) {
        int res = 0, l = s.length();
        int same  = 1, diff = 0;
        int i = 1;
        while(i < l)  {
            char tmp = s.charAt(i-1);
            //计算相同的
            while(i < l && tmp == s.charAt(i)) {
                i++;
                same++;
            }           
            //计算不同的 
            while(i < l && tmp != s.charAt(i)) {
                i++;
                diff++;
            }
            //取两者的最小值
            res = res + Math.min(same, diff);
            //更新
            same = diff;
            diff = 0;            
        }
        return res;
    }
}

11. 盛最多水的容器

力扣传送门

思路：双指针
以小的向内移动获得大的。假如S是小的B是大的，S这边小，就选S，然后不断往内移动，直到找到比S大的。容量的计算等于S×(B-S)，只有找到比S大的才有机会获得更大的容量。

class Solution {
    public int maxArea(int[] height) {
        int l=0;//左
        int r=height.length-1;//右
        int sum=Math.min(height[l],height[r])*(r-l);  //初始化

        while(l<r){
			//那边小选那边进行内移
            if(height[l]<=height[r]){
                int i=l+1;
                while(i<r && height[l]>=height[i]) i++; //直到找到比之前大的
                l=i;
                int temp=Math.min(height[i],height[r])*(r-i);
                if(sum<temp){
                     sum=temp;
                }                
            }else{
                int i=r-1;
                while(l<i && height[r]>=height[i]) i--; //同上
                r=i; 
                int temp=Math.min(height[i],height[l])*(i-l);
                if(sum<temp){
                     sum=temp;
                }                               
            }
           
        }

        return sum;
    }
}