Two Pointers Day

(1)Reverse String

解题思路简单明了，但是要注意时间复杂度问题！！！

代码如下：（声明一个与字符串等长的char数组，然后倒序区字符串中的字符，放入数组即可。）

 public class Solution {
     public String reverseString(String s) {
         char[] chars = new char[s.length()];
         int index = 0;
         for (int i = s.length() - 1; i >= 0; i--) {
             chars[index++] = s.charAt(i);
         }
         return new String(chars);
     }
 }

(2) Reverse Vowels of a String

解题思路一：

使用start和end两个指针，依次找到最前端和最后端的两个元音字母互换位置，然后start++，end-- ，直至start不小于end结束即可。

代码如下：

 public class Solution {
     public String reverseVowels(String s) {
         if(s == null || s.length()==0) return s;
         String vowels = "aeiouAEIOU";
         char[] chars = s.toCharArray();
         int start = 0;
         int end = s.length()-1;
         while(start<end){
             //while(start<end && !vowels.contains(chars[start]+""))
             while(start<end && vowels.indexOf(chars[start]) == -1){
                 start++;
             }
             //while(start<end && !vowels.contains(chars[end]+""))
             while(start<end && vowels.indexOf(chars[end]) == -1){
                 end--;
             }

             char temp = chars[start];
             chars[start] = chars[end];
             chars[end] = temp;

             start++;
             end--;
         }
         return new String(chars);
     }
 }

解题思路二：

使用hashset，首先找到所有元音字母所在的位置并记录，然后依然是最前最后的元素进行互换。

代码如下：

public class Solution {
    public String reverseVowels(String s) {
        int[] pos = new int[s.length()];
        int cnt = 0;
        HashSet<Character> vowel = new HashSet<Character>();
        vowel.add('a');
        vowel.add('e');
        vowel.add('i');
        vowel.add('o');
        vowel.add('u');
        vowel.add('A');
        vowel.add('E');
        vowel.add('I');
        vowel.add('O');
        vowel.add('U');

        for (int i = 0; i < s.length(); i++) {
            if (vowel.contains(s.charAt(i))) {
                pos[cnt] = i;
                cnt++;
            }
        }

        char[] ans = new char[s.length()];
        ans = s.toCharArray();
        for (int i = 0; i < cnt; i++) {
            ans[pos[i]] = s.charAt(pos[cnt - i - 1]);
        }
        return String.valueOf(ans);
    }
}

（3）Valid Palindrome

解题思路：利用s.replaceAll（字符串要匹配的正则式，替换字符串）来使字符串只含有字母和数字，然后前后依次比较即可。

代码如下：

 public class Solution {
     public boolean isPalindrome(String s) {
         String regex = "([^A-Za-z0-9])";
         String replacement = "";
         s = s.replaceAll(regex, replacement);//将不是字母和数字的替换掉
         for (int i = 0; i < s.length() / 2; i++) {
             if (Character.toLowerCase(s.charAt(i)) == Character.toLowerCase(s.charAt(s.length()-1-i)))
                 continue;
             else
                 return false;
         }
         return true;
     }
 }

（4）Implement strStr()

strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。

解题思路一：

在Java中，有一个API函数名indexof（），

它返回指定子字符串第一次出现在此字符串中的索引。

代码如下：

 public class Solution {
     public int strStr(String haystack, String needle) {
         int i;
         i = haystack.indexOf(needle);
         return i;
     }
 }

解题思路二：不使用indexof()函数。

从haystack的第一个位置，开始逐个判断是不是子串。如果整个子串都匹配了，那么就返回，否则继续往下挪位置。

注意要看haystack剩余的长度跟needle比是不是足够多，不够的话也就不用往后比了。

代码如下：

 public class Solution {
     public int strStr(String haystack, String needle) {
       for (int i = 0; ; i++) {
         for (int j = 0; ; j++) {
           if (j == needle.length()) {
               return i;//返回子字符串第一次出现的位置
           }
           if (i + j == haystack.length()) {
               return -1;
           }
           if (needle.charAt(j) != haystack.charAt(i + j)) {
               break;//跳出内部for循环
           }
         }
       }
     }
 }