动态算法（基础六）笔记回顾

1、验证回文串

示例 1：

输入: s = "A man, a plan, a canal: Panama"
输出：true
解释："amanaplanacanalpanama" 是回文串。
示例 2：

输入：s = "race a car"
输出：false
解释："raceacar" 不是回文串。
示例 3：

输入：s = " "
输出：true
解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
由于空字符串正着反着读都一样，所以是回文串。

/**
 * @param {string} s
 * @return {boolean}
 */
var isPalindrome = function(s) {
    let res=s.toLowerCase().replace(/[^a-z0-9]/gi, '').trim();//tolowercase转小写，replac非字母的全都换成哦那个个，trim去掉空格
    let res1= res.split("").reverse().join("");    //变为字符串
    if(res==""){                                   //空的返回true
        return true;
    }
    if(res === res1){                               //相等返回true
        return true;
    }
    return false;                                   //其余返回false
};

2、字符串转换整数 (atoi)

示例 1：

输入：s = "42"
输出：42
解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
第 1 步："42"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："42"（读入 "42"）
           ^
解析得到整数 42 。
由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。
示例 2：

输入：s = "   -42"
输出：-42
解释：
第 1 步："   -42"（读入前导空格，但忽视掉）
            ^
第 2 步："   -42"（读入 '-' 字符，所以结果应该是负数）
             ^
第 3 步："   -42"（读入 "42"）
               ^
解析得到整数 -42 。
由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。
示例 3：

输入：s = "4193 with words"
输出：4193
解释：
第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
             ^
解析得到整数 4193 。
由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。

/**
 * @param {string} s
 * @return {number}
 */
var myAtoi = function (str) {
    const number = parseInt(str, 10);       //parseint将字符串转为number
    const Max = Math.pow(2, 31) - 1;        //设定最大临界
    const Min = Math.pow(-2, 31);           //设定最小临界
    
                                            // 无法转换的情况返回 0
    if (isNaN(number)) {
        return 0;
    }
                                            // 转换结果超出范围的情况
    if (number < Min || number > Max) {
        return number < 0 ? Min : Max;      //三目运算
    }
    return number;                          //返回值
};

3、实现 strStr()

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

/**
 * @param {string} haystack
 * @param {string} needle
 * @return {number}
 */
var strStr = function(haystack, needle) {
    const n = haystack.length, m = needle.length;     //分别获取两个字符串的长度
    for (let i = 0; i + m <= n; i++) {                //判断haystack是否比needle长
        let flag = true;                              
        for (let j = 0; j < m; j++) {                 //needle位数循环
            if (haystack[i + j] != needle[j]) {       //判断haystack和needle相同位数值是否一样
                flag = false;                         //不一样跳出循环
                break;
            }
        }
        if (flag) {                                  //然后再找haystack的下一位，直到找到
            return i;                                //打印出第一次出现的下标
        }  
    }
    return -1;                                       //没有就返回-1
};

4、外观数列

示例 1：

输入：n = 1
输出："1"
解释：这是一个基本样例。
示例 2：

输入：n = 4
输出："1211"
解释：
countAndSay(1) = "1"
countAndSay(2) = 读 "1" = 一 个 1 = "11"
countAndSay(3) = 读 "11" = 二 个 1 = "21"
countAndSay(4) = 读 "21" = 一 个 2 + 一 个 1 = "12" + "11" = "1211"

/**
 * @param {number} n 
 * @return {string} 
 */
var countAndSay = function(n) {
    let str = "1"; // 初始化外观数列的第一项为 "1"
    for (let i = 2; i <= n; ++i) { // 循环计算第 2 到第 n 项的外观数列
        const sb = []; // 创建一个空数组 sb，用于存储每一项的外观数列字符串
        let start = 0; // 初始化起始位置 start 为 0
        let pos = 0; // 初始化当前位置 pos 为 0

        while (pos < str.length) { // 开始遍历当前项的外观数列字符串
            while (pos < str.length && str[pos] === str[start]) { // 寻找连续相同字符的结束位置
                pos++; // 当前位置向后移动，直到遇到不同的字符
            }
            sb.push('' + (pos - start) + str[start]); // 将连续相同字符的数量和字符本身转换为字符串，放入数组 sb 中
            start = pos; // 更新起始位置为当前位置
        }
        str = sb.join(''); // 将数组 sb 中的元素连接成一个字符串，作为下一项的外观数列字符串
    }
    
    return str; // 返回生成的外观数列的第 n 项
};

5、最长公共前缀

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"
示例 2：

输入：strs = ["dog","racecar","car"]
输出：""
解释：输入不存在公共前缀。

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
  let res=strs[0]                               //把strs里的第一个字符串拿出（拿哪个都无所谓的）
  for(let i=1;i<strs.length;i++){               //和strs里的之后做对比                 
      while(strs[i].indexOf(res) !=0){          //用indexof进行检索看res是否存在在strs中
          res=res.substring(0,res.length-1)     //如果没检索到，说明没有公共，那么把res去掉一位，直到res减到能够检索到，也就是有公共前缀
      }
  }      
  return res;                                   //把公共前缀打印出来
};