2000. 反转单词前缀
先循环找到等于ch的字母,此时可知道i,然后前后两个指针,while循环去逐个swap
class Solution {
public boolean isLetter(char ch){
return ch >'a' || ch <'z' || ch > 'A' || ch < 'Z';
}
public void swap(char[] chs,int i,int j){
char tmp = chs[i];
chs[i] = chs[j];
chs[j] = tmp;
}
public String reversePrefix(String word, char ch) {
int i;
char[] chs = word.toCharArray();
for(i=0;i < word.length();++i){
if(chs[i] == ch){
break;
}
}
if(i == word.length()){
return word;
}
int j=i;
i = 0;
while(i <= j){
swap(chs,i,j);
++i;
--j;
}
return new String(chs);
}
}
917. 仅仅反转字母
class Solution {
private void swapLetterChar(char[] chars, int left, int right) {
char tmp = chars[left];
chars[left] = chars[right];
chars[right] = tmp;
}
public String reverseOnlyLetters(String s) {
int n = s.length();
char[] chars = s.toCharArray();
int left = 0, right = n - 1;
while (true) {
while(left<right&&!Character.isLetter(s.charAt(left))){
left++;
}
while (right>left&&!Character.isLetter(s.charAt(right))){
right--;
}
if(left>=right){
break;
}
swapLetterChar(chars,left,right);
left++;
right--;
}
return String.valueOf(chars);
}
}
475. 供暖器
两个数组排序,排序后的供暖器数组,可以把它暂时看成是一个区域,然后开始for循环遍历房子,每遍历一个房子,
就考虑以下几种情况
-
房子的位置小于供暖区域(也就是最左侧的供暖器),则半径是供暖器位置-房子的位置
-
房子的位置大于供暖区域(也就是最左侧的供暖器),则半径是房子的位置-供暖器的位置
-
房子的位置在供暖区域里,则进行二分查找,找到那个我们需要的供暖器的下标ans
以上集中情况,在循环里用if else if 去表达即可
最后ret,x取最大值是因为要覆盖所有房子 肯定要选最大值
class Solution {
public int findRadius(int[] houses, int[] heaters) {
Arrays.sort(houses);
Arrays.sort(heaters);
int x,i;
int ans;
int ret=0;
for(i =0;i<houses.length;++i){
if(houses[i] < heaters[0]){
x = heaters[0]-houses[i];
}else if(houses[i] > heaters[heaters.length-1]){
x = houses[i] - heaters[heaters.length-1];
}else {
ans = -1;
int l = 0,r=heaters.length -1;
while(l <= r){
int mid = (l+r)>>1;
if(heaters[mid] <= houses[i]){
l = mid+1;
ans = mid;
}else{
r = mid -1;
}
}
if(ans == heaters.length-1){
x = houses[i] - heaters[ans];
}else{
x = Math.min(heaters[ans+1]-houses[i],houses[i] - heaters[ans]);
}
}
ret = Math.max(x,ret);
}
return ret;
}
}
面试题 16.06. 最小差
和475. 供暖器一样的解法,只是这个地方求的最小值,然后要注意数据的大小,要用long型来存储,否则会产生溢出,结果就不对了
class Solution {
public int smallestDifference(int[] houses, int[] heaters) {
Arrays.sort(houses);
Arrays.sort(heaters);
long x;
int i;
int ans;
long ret=1000000000L;
ret*=ret;
for(i =0;i<houses.length;++i){
if(houses[i] < heaters[0]){
x = (long)heaters[0]-(long)houses[i];
}else if(houses[i] > heaters[heaters.length-1]){
x = (long)houses[i] - (long)heaters[heaters.length-1];
}else {
ans = -1;
int l = 0,r=heaters.length -1;
while(l <= r){
int mid = (l+r)>>1;
if(heaters[mid] <= houses[i]){
l = mid+1;
ans = mid;
}else{
r = mid -1;
}
}
if(ans == heaters.length-1){
x = (long)houses[i] - (long)heaters[ans];
}else{
x = Math.min((long)heaters[ans+1]-(long)houses[i],(long)houses[i] - (long)heaters[ans]);
}
}
ret = Math.min(x,ret);
}
return (int)ret;
}
}