初级算法（五）

1、引言

2、验证回文串

​ 和前面的找不同数，有点类似，主要是利用双指针。

	 /**
     *给定一个字符串s，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写
     * 使用双指针，执行用时：3ms,内存消耗：41.6MB
     * 注意需要考虑数字字符，并且指针只有指向英文字母和数字字符的时候才进行比较
     * @param s
     * @return
     */
    public boolean isPalindrome(String s) {
        if(s.length()==1)
            return true;
        String s1 = s.toLowerCase();
        int i=0;
        int j=s1.length()-1;
        while(i<j){
          while(s1.charAt(i)<48||(s1.charAt(i)>57&&s1.charAt(i)<97)||s1.charAt(i)>122){
             if(i<j){
                 i++;
             }else{
                 break;
             }
          }
          while(s1.charAt(j)<48||(s1.charAt(j)>57&&s1.charAt(j)<97)||s1.charAt(j)>122){
             if(i<j) {
                 j--;
             }else {
                  break;
              }
          }
          if(s1.charAt(i)==s1.charAt(j)){
              i++;
              j--;
          }else{
              return false;
          }
        }
        return true;
    }

3、字符串转换整数

这道题没有什么特别的算法思想，就是简单的理解，算是暴力解决吧。

	/**
     * 字符串转换为整数,将一个数字字符串转换为一个32位有符号整数
     * 执行用时1ms,内存消耗41MB
     * @param s
     * @return
     */
    public int myAtoi(String s) {
        char[] chars = s.toCharArray();
        int length = chars.length;
        int index = 0;
        // 先去除空格
        while (index < length && chars[index] == ' '){
            index++;
        }
        // 极端情况 "  " 和""
        if(index >= length){
            return 0;
        }
        // 再判断符号
        int sign =  1;
        if(chars[index] == '-' || chars[index] == '+'){
            if(chars[index] == '-'){
                sign = -1;
            }
            index++;
        }
        int result = 0;
        int temp = 0;
        while (index < length){
            int num = chars[index] - '0';
            if(num > 9 || num < 0){
                break;
            }
            temp = result;
            result = result * 10 + num;
            // 越界后，数值和期望数值发生变化，取余再除10获取原始值，比对判断
            if(result/10 !=temp){
                if(sign > 0){
                    return Integer.MAX_VALUE;
                }else {
                    return Integer.MIN_VALUE;
                }
            }
            index++;
        }
        return result*sign;
    }

4、实现strStr()

也是利用双指针，主要是其中有一个指针的退回操作可能有点难理解。

	 /**
     * 返回needle字符串在haystack字符串中第一次出现的位置
     * 使用双指针，在主字符串中截取从字符串的。
     * 执行用时1ms,内存消耗39MB
     * @param haystack
     * @param needle
     * @return
     */
    public int strStr(String haystack, String needle) {
        if(needle==" ")
            return 0;
        int i=0;
        int j=0;
        while(i<haystack.length()&&j<needle.length()){
            if(haystack.charAt(i)==needle.charAt(j)){
                i++;
                j++;
            }else{
                i=i-j+1; //如果不匹配，就回退，从第一次匹配的下一次开始
                j=0;
            }
            if(j==needle.length())
                return i-j;
        }
        return -1;
    }

当然也可以使用简单的Java自带的api，Java自带的api很简单，但是没有起到刷题的作用。

    /**
     * 返回needle字符串在haystack字符串中第一次出现的位置
     * 使用JavaApi中indexOf
     * 执行用时0ms,内存消耗39.4MB
     * @param haystack
     * @param needle
     * @return
     */
    public int strStr2(String haystack, String needle) {
        return haystack.indexOf(needle);
    }

5、外观数列

这里涉及了一点递归的思想，主要是根据前一项求后一项。

    /**
     * countAndSay(n)代表的是对n-1的理解，这里使用了递归
     * 执行用时：2ms,消耗内存38.8MB
     * @param n
     * @return
     */
    public String countAndSay(int n) {
        if(n==1)
            return "1";
        String s = countAndSay(n - 1);
        //StringBuilder 可以让一个字符串动态增加
        StringBuilder result=new StringBuilder();
        char c = s.charAt(0);
        int count=0;
        for (int i = 0; i <s.length(); i++) {
            if(c==s.charAt(i)){
                count++;//计数器代表的是几个中的几
            }else{
                result.append(count).append(c);
                count=1;
                c=s.charAt(i);
            }
        }
        result.append(count);
        result.append(c);
        return result.toString();
    }