关于字符串的算法题：回文数，字符串相乘，字符串转换整数，反转字符串中的单词III,反转字符串,

1. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

java答案：

1. 首先先转成字符串，然后匹配后面的字符是否等于前面的字符，如果不等于，直接返回false
class Solution {
    public boolean isPalindrome(int x) {
        if(x==0){
            return true;
        }
        String str = ""+x;
        for(int i=0;i<=str.length()/2;i++){
            if(str.charAt(i)!=str.charAt(str.length()-1-i)){
                return false;
            }
        }
        System.out.println(str);
        return true;
    }
}
2. 直接将x反转成字符串，判断两个字符串是否相等
class Solution {
    public boolean isPalindrome(int x) {
        String reversedStr = (new StringBuilder(x + "")).reverse().toString();
        return (x + "").equals(reversedStr);
    }
}
3. 先判断x是几位数，将x首尾一块往中间走，判断是否相等
class Solution {
    public boolean isPalindrome(int x) {
        //边界判断
        if (x < 0) return false;
        int div = 1;
        // 先判断x是几位
        while (x / div >= 10) div *= 10;
        //将前面的数和后面的数进行比较
        while (x > 0) {
            int left = x / div;
            int right = x % 10;
            if (left != right) return false;
            x = (x % div) / 10;
            div /= 100;
        }
        return true;
    }
}
4. 从后面走一半，根据奇偶性，然后和前面的数比较，
class Solution {
    public boolean isPalindrome(int x) {
        //是负数或10的倍数，返回fasle
        if (x < 0 || (x % 10 == 0 && x != 0)) return false;
        int revertedNumber = 0;
        //当x<=revertedNumber,说明走完一半了
        while (x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }
        return x == revertedNumber || x == revertedNumber / 10;
    }
}

JavaScript答案：

1. 使用字符串比较，数组反转，
/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    if(x<0){
      return false;   
    }
    var str = x+"";
    var s = str.split("").reverse().join("");
    return str==s;
};
2. 先计算x是几位数，然后根据收尾往中间走，判断
var isPalindrome = function(x) {
    if(x<0){
      return false;   
    }
    let div=1;
    while(x/div>=10){
       div=div*10;   
    }
    while(x>0){
       var left = Math.floor(x/div);
       var right=x%10;
       if(left!=right){
         return false; 
       }
       x=Math.floor((x%div)/10);
       Math.floor(div/=100);
    }
    return true;
};
3.
var isPalindrome = function(x) {
    if(x<0 || x%10==0 && x!=0){
      return false;   
    }
    var num = 0;
    while(x>num){
         num = num*10+x%10;
         x=Math.floor(x/10);
    }
    return x==num || x==Math.floor(num/10);
};

注意：
数组转换成字符串：arr.join("");
字符串转成数组：str.split("");
数组反转：arr.reverse();
字符串是否相等: str1==str2;

2. 反转字符串中的单词III

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:
输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

java答案：

1. 使用StringBuffer的反转方法，然后将字符串转成数组，反转数组。
class Solution {
    public String reverseWords(String s) {
        if(s.length()==0 || s.equals(" ")){
            return s;
        }
        String str = new StringBuffer(s).reverse().toString();
        String[] arr = str.split(" ");
        //System.out.println(str);
        StringBuffer sb = new StringBuffer();
        for(int i=arr.length-1;i>=0;i--){
            if(i==0){
                sb.append(arr[i]);
            }else
                sb.append(arr[i]).append(" ");
        }
        return sb.toString();
    }
}
2. 利用数组双指针思想：
class Solution{
public static String reverseWords(String s) {
        if (s == null || s.length() < 2) {
            return s;
        }
        // 将字符串转化为数组
        char[] arr = s.toCharArray();
        int l = 0;
        int r = 0;
        //
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == ' ') {
                while (l < r) {
                    char t = arr[l];
                    arr[l] = arr[r];
                    arr[r] = t;
                    l++;
                    r--;
                }
                l = i + 1;
                r = i + 1;
            } else {
                r = i;
            }
        }
        while (l < r) {
            char t = arr[l];
            arr[l] = arr[r];
            arr[r] = t;
            l++;
            r--;
        }
        return new String(arr);
    }
}

JavaScript答案：

1. 使用字符串和数组的转换的方法
/**
 * @param {string} s
 * @return {string}
 */
var reverseWords = function(s) {
        if(s.length==0 || s==null){
            return s;
        }
        var arr = s.split(" ");
        for(var i=0;i<arr.length;i++){
           arr[i] = arr[i].split("").reverse().join("");
        }
        var str = arr.join(" ");
        return str;
};
2. 使用双指针
var reverseWords = function(s) {
        if(s.length==0 || s==null){
            return s;
        }
        var arr = s.split("");
        var l=0,r=0; 
        for(var i=0;i<arr.length;i++){
           if(arr[i]==' '){
              while(l<r){
                    var temp = arr[r];
                    arr[r] =arr[l];
                    arr[l] = temp;
                    l++;
                    r--;
              }
               l=i+1;
               r=i+1;
           }else{
               r=i;
           }
        }
        while(l<r){
            var temp = arr[r];
            arr[r] =arr[l];
            arr[l] = temp;
            l++;
            r--;
        }
        return arr.join("");
};

3. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

java答案：

1.使用双指针，前后转换
class Solution {
    public void reverseString(char[] s) {
        if(s==null || s.length<2)
            return ;
        for(int i=0,j=s.length-1;i<j;i++,j--){
            char ch = s[j];
            s[j] = s[i];
            s[i] =ch;
        }
    }
}
2. 位运算，把两个值交换的，异或相同是0，不同是1
            s[i] ^= s[end];
            s[end] ^= s[i];
            s[i] ^= s[end];

JavaScript答案：

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
     s.reverse();
};

4. 字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

示例 1:
输入: num1 = “2”, num2 = “3”
输出: “6”

示例 2:
输入: num1 = “123”, num2 = “456”
输出: “56088”

说明：
num1 和 num2 的长度小于110。
num1 和 num2 只包含数字 0-9。
num1 和 num2 均不以零开头，除非是数字 0 本身。
不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。
java答案：

1. 不能直接转成整数处理，那就按位进行计算，使用数组保存
class Solution {
    public String multiply(String num1, String num2) {
        if(num1.length()==0 || num2.length()==0){
            return "";
        }
        if(num1.equals("0") || num2.equals("0")){
            return "0";
        }
        int[] arr = new int[num1.length()+num2.length()];
        for(int i=num1.length()-1;i>=0;i--){
            for(int j=num2.length()-1;j>=0;j--){
                int result = ((num2.charAt(j)-'0')*(num1.charAt(i)-'0'))+arr[i+j+1];
                arr[i+j+1] = result%10;
                arr[i+j] += result/10;              
            }
        }
        StringBuffer sb = new StringBuffer();
        int index=0;
         while (index<arr.length&&arr[index]==0){
             index++;
         }
         for (int i=index;i<arr.length;i++)
             sb.append(arr[i]);
         return sb.toString();
    }
}
2.
class Solution {
    public String multiply(String num1, String num2) {
       if (num1.equals("0") || num2.equals("0")) {
			return "0";
		}
		int length1 = num1.length();
		int length2 = num2.length();
		StringBuilder str = new StringBuilder();
		int[] arrayInt = new int[length1 + length2];
		for (int i = length1 - 1; i >= 0; i--) {
			for (int z = length2 - 1; z >= 0; z--) {
				int number1 = num1.charAt(i) - 48;
				int number2 = num2.charAt(z) - 48;
				arrayInt[i + z] += number1 * number2;
				if (arrayInt[i + z] >= 10 && (i + z) != 0) {
					arrayInt[i + z - 1] += arrayInt[i + z] / 10;
					arrayInt[i + z] = arrayInt[i + z] % 10;
				}
			}
		}
		for (int i = 0; i <= length1 + length2 - 2; i++) {
			str.append(arrayInt[i]);
		}
		return str.toString();
    }
}

JavaScript答案：

/**
 * @param {string} num1
 * @param {string} num2
 * @return {string}
 */
var multiply = function(num1, num2) {
    if(num1.length==0 || num2.length==0){
       return "";
    }
    if(num1=="0" || num2=="0"){
       return "0";
    }
    var arr = new Array(num1.length+num2.length).fill(0);
    for(var i=num1.length-1;i>=0;i--){
        for(var j=num2.length-1;j>=0;j--){
            var res = ((num1[i]*num2[j])+arr[i+j+1]);
            arr[i+j+1] = res%10;
            arr[i+j]+=Math.floor(res/10);
        }
    }
    for(var i=0;i<arr.length;i++){
        if(arr[i]==0){
           arr.splice(i,1);
           i--;
        }else{
            break;
        }
    }
    var str = arr.join("");
    console.log(str);
    return str;
};

5. 字符串转换整数

请你来实现一个 atoi 函数，使其能将字符串转换成整数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。

注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
在任何情况下，若函数不能进行有效的转换时，请返回 0。

说明：
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−2³¹, 2³¹ − 1]。如果数值超过这个范围，请返回 INT_MAX (2³¹ − 1) 或 INT_MIN (−2³¹) 。

示例 1:
输入: “42”
输出: 42

示例 2:
输入: " -42"
输出: -42
解释: 第一个非空白字符为 ‘-’, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:
输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。

示例 4:
输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。

示例 5:
输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−2³¹) 。
java答案：

1. 双指针，一个查第一个是否为正负号以及整数，第二个查整数的长度
class Solution {
    public int myAtoi(String str) {
        int i = 0, j = 0, len = str.length();
        boolean negative = false;
        //第一个for循环是判断第一个非空字符是数还是正负号，以及其他字符，
        for (i = 0; i < len; i++) {
            if ('0' <= str.charAt(i) && str.charAt(i) <= '9') {
                System.out.println("str.charAt(i)"+str.charAt(i));
                break;
            } else if (str.charAt(i) == '-' || str.charAt(i) == '+') {
                negative = str.charAt(i) == '-'; //判断是否为负号
                i++;
                break;
            } else if (str.charAt(i) != ' ') {
                return 0;
            }
        }
        //第二个for循环是找出数的长度
        for (j = i; j < len; j++) {
             System.out.println("str.charAt(j)"+str.charAt(j));
            if (str.charAt(j) < '0' || '9' < str.charAt(j)) {
                break;
            }
        }
        int ret = 0;
        String num = str.substring(i, j); //截取整数，不加正负号的
         System.out.println("num"+num);
        for (int x = 0; x < num.length(); x++) { //判断是否溢出
            int cur = num.charAt(x) - '0';
            if (negative) {
                //这里判断溢出的情况和第7题一样
                if (ret < Integer.MIN_VALUE / 10|| ret == Integer.MIN_VALUE / 10 && cur > 8) {
                    return Integer.MIN_VALUE;
                }
                ret = ret * 10 - cur;
            } else {
                if (ret > Integer.MAX_VALUE / 10 || ret == Integer.MAX_VALUE / 10 && cur > 7) {
                    return Integer.MAX_VALUE;
                }
                ret = ret * 10 + cur;
            }
        }
        return ret;
    }
}
2. 正则表达式
// 整体思路
// trim()函数去除收尾空格，
// 使用Java正则表达式匹配到合适的字符串。
// 未匹配到则返回0，
// 匹配到字符串后判断是否只是一个+或-，这种情况同样返回0（例如只输入+或-）。
// 以上判断都通过使用Integer.parseInt()将字符串转成数字，并根据异常判定是否溢出
// 溢出的返回值可以由字符串第一个字符是否是-来判定。

// 存在的问题
// 对于正则匹配的结果处理显得冗余，还可以优化
// 异常判定的地方可能不够准确

import java.util.regex.Pattern;
import java.util.regex.Matcher;
class Solution {
    public int myAtoi(String str) {
        str=str.trim();
        String pattern="^[\\+\\-\\d]\\d*";//正则表达式，表示以正号或负号或数字开头，且后面是0个或多个数字
        Pattern p=Pattern.compile(pattern);
        Matcher m=p.matcher(str);
        String res="";
        if(m.find()){//能匹配到
            res=str.substring(m.start(),m.end());
        }else{//不能匹配到
            return 0;
        }
        //能匹配到但只有一个+-号，也返回0
        if(res.length()==1&&(res.charAt(0)=='+'||res.charAt(0)=='-')){
            return 0;
        } 
        try{
            int r=Integer.parseInt(res);
            return r;
        }catch(Exception e){
            return res.charAt(0)=='-'?Integer.MIN_VALUE:Integer.MAX_VALUE;
        }
    }
}
3. 使用截取字符串的形式
// 假想使用插入合格元素的方式获取合格的字符串。
// 循环遍历整个字符串，将合格的元素放到新的字符串中，如果遇到一个不合格就立马停止循环，忽略剩余元素 时间复杂度为o(n) n为字符串的长度

class Solution {
    public int myAtoi(String str) {
        //去除掉前后的空格
        String str1 = str.trim();
        //存储最终过滤出来的字符串
        String str2 = null;
        //字符串不为空时并且字符串不全是空白字符串时才转换
        if(str1 != null && str1.isEmpty() == false){
            char f = str1.charAt(0);
            //判断字符串中的第一个非空格字符是不是一个有效整数字符
            if(f >= '0' && f <= '9' || f == '+'|| f == '-'){
                str2 = str1.substring(0,1); // 把第一位放进去(只能是数字、正负号)
                //这时候循环只要数字，因为正负号只能出现在第一位
                for(int i = 1; i<str1.length();i++){
                    if(str1.charAt(i) >= '0' && str1.charAt(i) <= '9'){
                        str2 = str1.substring(0,i+1);
                    }
                    //这是遇到不符合要求的字符，直接忽略剩余元素
                    else{break;}
                }
            }
        }
        //判断最终字符串是否为空或则只有一个正负号
        if(str2 == null || str2.equals("+") || str2.equals("-"))
            //此时str2是String对象，如果使用==比较则比较的时内存地址
            return 0;
        //最终转换成的数字
        int num = 0;
        //使用异常机制打印结果
        try{
            num = Integer.parseInt(str2);
        }catch (Exception e){
            if(str2.charAt(0) == '-')
                return Integer.MIN_VALUE;
            return Integer.MAX_VALUE;
        }
        return num;
    }
}

注意：

1. 判断数字是否溢出的方法：一个是for循环比较：
   if(是负数){
   if (ret < Integer.MIN_VALUE / 10|| ret == Integer.MIN_VALUE / 10 && cur > 8) {
   return Integer.MIN_VALUE;
   }
   ret = ret * 10 - cur;
   } else {
   if (ret > Integer.MAX_VALUE / 10 || ret == Integer.MAX_VALUE / 10 && cur > 7) {
   return Integer.MAX_VALUE;
   }
   ret = ret * 10 + cur;
   }
   一个是异常处理
   try{
   int r=Integer.parseInt(res);
   return r;
   }catch(Exception e){
   return res.charAt(0)==’-’?Integer.MIN_VALUE:Integer.MAX_VALUE;
   }
2. str.trim(); //去电字符串前后的空格
   str.isEmpty() //判断字符串是空字符串
3. 正则表达式：
   ^ 定义了以什么开始
   \d+ 匹配一个或多个数字
   ? 设置括号内的选项是可选的
   . 匹配 “.”
   String pattern="¹\d*";//正则表达式，表示以正号或负号或数字开头，且后面是0个或多个数字
   Pattern p=Pattern.compile(pattern); //创建Pattern对象
   Matcher m=p.matcher(str);//创建matcher对象
   while(m.find()) { //尝试查找与该模式匹配的输入序列的下一个子序列。
   count++;
   System.out.println("Match number "+count);
   System.out.println("start(): "+m.start()); //返回以前匹配的初始索引。
   System.out.println("end(): "+m.end());//返回最后匹配字符之后的偏移量。
   }

JavaScript答案：

1.
/**
 * @param {string} str
 * @return {number}
 */
var myAtoi = function(str) {
    var s= str.trim();
    if(s==""){
       return 0;
    }
    var i=0,j=0,len=s.length;
    var flag = false;
    for(i=0;i<len;i++){
        if(s.charAt(i)>='0' && s.charAt(i)<='9'){
           break;
        }else if(s.charAt(i)=='-' || s.charAt(i)=='+'){
            flag = s.charAt(i)=='-';
            i++;
            break;
        }else if(s.charAt(i)!=' '){
            return 0;         
        }
    }
    for(j=i;j<len;j++){
        if(s.charAt(i)<'0' || s.charAt(i)>'9'){
           break;
        }
    }
    var string = s.substring(0,j);
    if(string.length==1 && (s.charAt(0)=='-' || s.charAt(0)=='+')){
       return 0;
    }
    if(flag==true && parseInt(string)< -Math.pow(2,31)){
        return -Math.pow(2,31);
    }else if(flag==false && parseInt(string)> Math.pow(2,31)-1){
        return Math.pow(2,31)-1;
    }else{
        return parseInt(string);
    }
};
2. 从第一个数开始找的
var myAtoi = function(str) {
    var s= str.trim();
    var str1 = null;
    if(s.length!=0 && s!=""){
       var zero = s.charAt(0);
       if(zero>='0' && zero<='9' || zero=='-' || zero=='+'){
          str1=s.substring(0,1);  
          for(var i=1;i<s.length;i++){
            if(s.charAt(i)>='0' && s.charAt(i)<='9'){
               str1 = s.substring(0,i+1);
             }else{
                   break;
             }
         }
       }  
    }
    console.log(str1);
    if(str1==null || str1=="-" || str1=="+"){
       return 0;
    }
    if(str1.charAt(0)=='-' && parseInt(str1)< -Math.pow(2,31)){
        return -Math.pow(2,31);
    }else if(str1.charAt(0)!='-' && parseInt(str1)> Math.pow(2,31)-1){
        return Math.pow(2,31)-1;
    }else{
        return parseInt(str1);
    }
};
3. 使用parseInt方法，
var myAtoi = function(str) {
    let m = parseInt(str); 
    if (m <= Math.pow(-2, 31)) {
        return Math.pow(-2, 31) 
    } 
    if (m >= Math.pow(2, 31) - 1) { 
        return Math.pow(2, 31) - 1
    }
    return !parseInt(str) ? 0 : parseInt(str) 
};
4. 使用Number.isNaN()方法
var myAtoi = function(str) {
    // 替换掉e，防止parseFloat将 “12e16” 认成科学计数法
    str = str.trim().replace(/e/g, 'a');
    let num = parseFloat(str);
    num = Number.isNaN(num) ? 0 : num;
    const edge = Math.pow(2, 31);
    return Math.max(-edge, Math.min(edge - 1, num));
};

注意：

1. parseInt()和parseFloat ()方法传入的参数，如果字符串的第一个字符不能被转换为数字，那么 parseFloat() 和parseInt()会返回 NaN。
2. NaN与任何的判断都是false.
3. 可以通过调用 isNaN 函数来判断 parseFloat 的返回结果是否是 NaN。如果让 NaN 作为了任意数学运算的操作数，则运算结果必定也是 NaN。
   isNaN() 函数可用于判断其参数是否是 NaN，该值表示一个非法的数字.

---

1. \+\-\d ↩︎