玩转算法(四)——数组(指针碰撞)

字符串回文或反转

344. 反转字符串（简单）

344. 反转字符串

此题过于简单，过。

public void reverseString(char[] s) {
	int i = 0, j = s.length-1;
	
	while(i < j) {
		char a = s[i];
		s[i] = s[j];
		s[j] = a;
		i++;
		j--;
	}   	
}

345. 反转字符串中的元音字母（简单）

345. 反转字符串中的元音字母

此题和上题相似，前后遍历找到元音即可。

有几个需要注意的点：

• 方法传进来的是String类型，String类型是不可变的，需改为StringBuilder类型，最后再 toString()。
• 初始化一个list集合，初始化的数据比较多，可用Arrays.asList()进行初始化。
• while循环里面也有while循环来进行元音的定位，特别注意加上（ && i < j ），不然会数组索引越界。
• StringBuilder类型进行取值和更改用 charAt(i) 和 setCharAt(j,a)。

List<Character> charList = Arrays.asList('a','A','e','E','i','I','o','O','u','U');
public String reverseVowels(String s) {
	 	
	int i = 0, j = s.length()-1;  	
	StringBuilder res = new StringBuilder(s);
	
	while(i < j) {
		char m = res.charAt(i);
		char n = res.charAt(j);
		while(!charList.contains(m) && i < j)    
			m = res.charAt(++i);
		while(!charList.contains(n) && i < j)
			n = res.charAt(--j);
		
		char a = res.charAt(i);
		res.setCharAt(i,res.charAt(j));
		res.setCharAt(j,a);
		
		i++;
		j--;
	}  
	return res.toString();
}

125. 验证回文串（简单）

125. 验证回文串

同样要注意里面的while循环的 （&& i < j ）这个条件。

public boolean isPalindrome(String s) {
	s = s.toLowerCase();
	int i = 0,j = s.length()-1;
	
	while(i<=j) {
		char a = s.charAt(i);
		char b = s.charAt(j);
		
		while((!Character.isLetterOrDigit(a)) && i<j)
			a = s.charAt(++i);
		while((!Character.isLetterOrDigit(b)) && i<j)
			b = s.charAt(--j);   		
		
		if(a == b) {
			i++;
			j--;
		}else
			return false;
	}
	return true;
}

到达目标值或最大值

167. 两数之和 II - 输入有序数组（简单）

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

思路一：暴力解法，O(n²)。

思路二：从前往后遍历，后面的数组用二分查找法进行查找是否有对应的数，O(nlogn)。

思路三：对撞指针，O(n)。

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

11. 盛最多水的容器（中等）

11. 盛最多水的容器

思路，用对撞指针，容积 = min * (right - left) ，所以影响容积的是小的边和宽度。

public int maxArea(int[] height) {
	int i = 0, j = height.length-1;
	int capacity = 0;
	int maxCapacity = 0;
	
	while(i < j) {

		int left = height[i];
		int right = height[j];
		int mix = left < right ? left : right;
		int width = j - i;			
		capacity = width * mix;
		if(capacity > maxCapacity)
			maxCapacity = capacity;		
		if(left < right) {
			i++;
		}else 
			j--;  		
	}
	return maxCapacity;
}