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;
}
}