Leetcode刷题-(6~10)-Java+Python+JavaScript

算法题是程序员的基本功，也是各个大厂必考察的重点，让我们一起坚持写算法题吧

遇事不决，可问春风，春风不语，即是本心。

我们在我们能力范围内，做好我们该做的事，然后相信一切都事最好的安排就可以啦，慢慢来，会很快，向前走，别回头。

目录

1.Z字形变换

2.整数反转

3.字符串转换整数 (atoi)

4.回文数

5.正则表达式匹配

---

1.Z字形变换

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/zigzag-conversion/description/

思路：本题是标准的模拟，可以直接定义二维矩阵进行模拟填充，但是存在大量的空间浪费，本题可以定义numRows行的字符串数组，按照规则将元素拼接到相应的行，最后一以此遍历取出每行的数据拼接成字符串即可。

注：本题的难点在于找出拼接到哪一行的条件语句。

Java版：
?

class Solution {
    public String convert(String s, int numRows) {
        int n = s.length(), row = numRows ;
        if(row==1 || row >=n){
            return s ;
        }
        String ans = "" ;
        StringBuilder [] sb = new StringBuilder[row] ;
        for(int i=0; i<row; i++){
            sb[i] = new StringBuilder() ;
        }
        for(int i=0,x=0; i<n;i++){
            sb[x].append(s.charAt(i)) ;
            // 重点在此处，需要找出什么时候当前字符拼接到第x行
            if(i%(row*2-2) < row-1){
                x++  ;
            }else{
                x-- ;
            }
        }
        for(StringBuilder s1 : sb){
            ans += s1.toString() ;
        }
        return ans ;
    }
}

Python版：

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        n = len(s)
        row = numRows
        ans = ""
        if row == 1 or row >= n:
            return s
        
        matrix = ["" for _ in range(n)]
        x =  0
        t = row * 2 - 2 
        for i, ch in enumerate(s):
            matrix[x] += ch
            if i%t < row -1:
                x = x + 1
            else:
                x = x - 1
        
        for i in range(row):
            ans += matrix[i]
        return ans 

Js版：

/**
 * @param {string} s
 * @param {number} numRows
 * @return {string}
 */
var convert = function(s, numRows) {
    const n = s.length, row = numRows
    let ans = ""
    if(row==1 || row>=n){
        return s
    }
    const arr = new Array(row)
    for(let i=0; i<row; i++){
        arr[i] = "" 
    }
    for(let i=0,x=0; i<n; i++){
        arr[x] += s.charAt(i) 
        if(i % (row*2-2) < row -1){
            x ++ 
        }else{
            x -- 
        }
    }
    for(let i=0; i<row; i++){
        ans += arr[i] ;
    }
    return ans ;
     
};

2.整数反转

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/reverse-integer/description/

思路：找出反转公式就可以了，ans=ans*10+x%10 ， x = x / 10

最后的ans就是反转后整数，不过需要判断是否超出范围，也就是说ans定义为long，超出范围则返回0即可。

Java版：
?

class Solution {
    public int reverse(int x) {
        long ans = 0 ;

        while(x != 0){
            ans = ans*10 + x%10 ;
            x = x / 10 ;
            // 反转后的超过了范围就返回0，否则返回反转后的
            ans = ans > Integer.MAX_VALUE || ans < Integer.MIN_VALUE ? 0: (int)ans ;
        }
        return (int) ans ;
    
}
}

Python版：
?

class Solution:
    def reverse(self, x: int) -> int:
        ans = 0
        flag = False
        if x < 0:
            x = -x
            flag = True 
        while x != 0:
            ans = ans * 10 + x % 10 
            x = x // 10
        if ans > math.pow(2,31):
            return 0
        else:
            if flag:
                return -1 * ans 
            else :
                return ans 
      

Js版：

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    let ans = 0
    let flag = false
    if (x < 0){
        x = -x
        flag = true
    }
    while(x != 0){
        ans = ans * 10 + x % 10
        x = Math.floor(x / 10)
    }
    if(ans > Math.pow(2,31)){
        return 0 
    }else{
        if(flag){
            return -1 * ans 
        }else{
            return ans
        }
    }
};

3.字符串转换整数 (atoi)

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/string-to-integer-atoi/

思路：模拟题，遍历字符串，模拟出字符串转换成整数的过程即可，需要按照题目要求进行模拟。

Java版：

class Solution {
    public int myAtoi(String s) {
        String s1 = s.trim();
        long ans = 0 ;
        boolean flag = false ;
        for(int i=0; i<s1.length(); i++){
            char c = s1.charAt(i) ;
            if(c == '-' || c == '+' ){
                 if(i!=0){
                   break ;
               }
              flag = (c=='-' ? true : false) ;
              
            }else{
                if(Character.isDigit(c)){
                    ans = ans * 10 + (c - '0') ;
                    if(ans > Math.pow(2,31)-1 && !flag ){
                       return (int) Math.pow(2,31)  ;
                    }
                    if(flag && ans > Math.pow(2,31)){
                        return -1 * (int) Math.pow(2,31) - 1 ;
                    }
                }else{
                    break ;
                }
            }
        }
        return flag == true ? -1 * (int) ans : (int) ans ;
    }
}

Python版：
?

class Solution:
    def myAtoi(self, s: str) -> int:
        flag = False
        ans = 0
        s = s.strip()
        for i, c in enumerate(s):
            if c == '+' or c == '-':
                if i != 0:
                    break 
                if c == '-':
                    flag = True
            else:
                if(c.isdigit()):
                    ans = ans * 10 + int(c)
                    if flag == False and ans > math.pow(2,31) - 1:
                        return int(math.pow(2,31)) - 1
                    if flag and ans > math.pow(2,31):
                        return -1 * int(math.pow(2,31))
                else:
                    break 
        if flag:
            return - 1 * ans 
        else:
            return ans 

Js版：
?

/**
 * @param {string} s
 * @return {number}
 */
var myAtoi = function(s) {
    let ans = 0
    let flag = false 
    s = s.trim()
    for(let i=0; i<s.length; i++){
        const c = s.charAt(i) 
        if(c == '-' || c == '+'){
            if(i!=0){
                break 
            }
            flag = (c == '-') ? true : false 
        }else{
            if(!isNaN(parseFloat(c))){
                ans = ans * 10 + (c-'0')
                if(flag == false && ans > Math.pow(2,31)-1){
                    return Math.pow(2,31) - 1
                }
                if(flag && ans > Math.pow(2,31)){
                    return Math.pow(2,31) * -1 
                }
            }else{
                break ;
            }
        }
    }
    return flag ? -1 * ans : ans ;
};

4.回文数

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/palindrome-number/description/

思路：双指针方式是最常用的方式，当然也可以用字符串反转的方式。

Java版1：
?

class Solution {
    public boolean isPalindrome(int x) {
        String s = new String(x+"") ;
        int low = 0, high = s.length()-1 ;
        while(low < high){
            if(s.charAt(low) != s.charAt(high)){
                return false ;
            }else{
                low ++ ;
                high -- ;
            }
        }
        return true ;
    }
}

Java版2：

class Solution {
    public boolean isPalindrome(int x) {
        return (new StringBuilder(x+"").toString()).equals(new StringBuilder(x+"").reverse().toString()) ;
        
    }
}

Python版：

class Solution:
    def isPalindrome(self, x: int) -> bool:
        s = str(x)
        low = 0
        high = len(s) - 1
        while low < high:
            if s[low] != s[high]:
                return False
            else:
                low = low + 1
                high = high - 1
        return True

Js版：

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    const s = x.toString()
    let low = 0, high = s.length-1
    while (low < high){
        if(s.charAt(low) !== s.charAt(high)){
            return false 
        }else{
            low ++ 
            high --
        }
    }
    return true
};

5.正则表达式匹配

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/regular-expression-matching/description/

思路：本题是动态规划 ，省略....