字符串——面试考察高频算法题

目录

转换成小写字母

字符串转化为整数

反转相关的问题

反转字符串

k个一组反转

仅仅反转字母

反转字符串里的单词

验证回文串

判断是否互为字符重排

最长公共前缀

字符串压缩问题


转换成小写字母

给你一个字符串 s ,将该字符串中的大写字母转换成相同的小写字母,返回新的字符串。

每个字母都是有确定的 ASCII的,因此我们可以根据 码表操作字符串即可。

常见ASCII范围是:

  • a-z:97-122

  • A-Z:65-90

  • 0-9:48-57

java 复制代码
public static String toLowerCase(String s) {
    int n = s.length();
    char[] chars = s.toCharArray();
    for (int i = 0; i < n; ++i) {
        if (chars[i] >= 65 && chars[i] <= 90) {
            chars[i] += 32;
        }
    }
    String str = new String(chars);
    return str;
}

字符串转化为整数

请你来实现一个 myAtoi(string s) 函数,使其能将字符串转换成一个 32 位有符号整数

函数 myAtoi(string s) 的算法如下:

  1. 空格: 读入字符串并丢弃无用的前导空格(" "

  2. 符号: 检查下一个字符(假设还未到字符末尾)为 '-' 还是 '+'。如果两者都不存在,则假定结果为正。

  3. **转换:**通过跳过前置零来读取该整数,直到遇到非数字字符或到达字符串的结尾。如果没有读取数字,则结果为0。

  4. 舍入: 如果整数数超过 32 位有符号整数范围 [−2(31), 2(31 )− 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 −2(31) 的整数应该被舍入为 −2(31) ,大于 2(31 )− 1 的整数应该被舍入为 2(31 )− 1

返回整数作为最终结果。

java 复制代码
public static int myAtoi(String str) {
    int len = str.length();
    char[] charArray = str.toCharArray();
    // 1、去除前导空格
    int index = 0;
    while (index < len && charArray[index] == ' ') {
        index++;
    }
    
    // 2、如果已经遍历完成(针对极端用例 "      ")
    if (index == len) {
        return 0;
    }
    
    // 3、如果出现符号字符,仅第 1 个有效,并记录正负
    int sign = 1;
    char firstChar = charArray[index];
    if (firstChar == '+') {
        index++;
    } else if (firstChar == '-') {
        index++;
        sign = -1;
    }
    
    // 4、将后续出现的数字字符进行转换
    // 不能使用 long 类型,这是题目说的
    int res = 0;
    while (index < len) {
        char currChar = charArray[index];
        // 4.1 先判断不合法的情况
        if (currChar > '9' || currChar < '0') {
            break;
        }
    
        // 这是解决溢出问题的经典处理方式。
        if (res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && (currChar - '0') > Integer.MAX_VALUE % 10)) {
            return Integer.MAX_VALUE;
        }
        if (res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && (currChar - '0') > -(Integer.MIN_VALUE % 10))) {
            return Integer.MIN_VALUE;
        }
    
        // 合法的情况下,才考虑转换,每一步都把符号位乘进去
        // 想想这里为什么要带着sign乘
        res = res * 10 + sign * (currChar - '0');
        index++;
    }
    return res;
}

反转相关的问题

反转字符串

编写一个函数,其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间,你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

  • 一看就是双指针问题!太经典了!
java 复制代码
public void reverseString(char[] s) {
       if (s == null || s.length() == 0) {
            return ;
        }
        int n = s.length;
        for (int left = 0, right = n - 1; left < right; ++left, --right) {
            char tmp = s[left];
            s[left] = s[right];
            s[right] = tmp;
        }
    }

k个一组反转

给定一个字符串 s 和一个整数 k,从字符串开头算起,每计数至 2k 个字符,就反转这 2k 字符中的前 k 个字符。

  • 如果剩余字符少于 k 个,则将剩余字符全部反转。

  • 如果剩余字符小于 2k 但大于或等于 k 个,则反转前 k 个字符,其余字符保持原样。

反转每个下标从 2k的倍数开始的,长度为 k的子串。若该子串长度不足 k,则反转整个子串。

java 复制代码
public String reverseStr(String s, int k) {
       if (s == null || s.length() == 0) {
            return s;
        }
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i += 2 * k) {
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);
    }

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }

仅仅反转字母

给定一个字符串 S,返回 "反转后的" 字符串,其中不是字母的字符都保留在原地,而所有字母的位置发生反转。

示例1:

输入:"ab-cd"

输出:"dc-ba"

示例2:

输入:"a-bC-dEf-ghIj"

输出:"j-Ih-gfE-dCba"

示例3:

输入:"Test1ng-Leet=code-Q!"

输出:"Qedo1ct-eeLg=ntse-T!"

  • 栈:将 s 中的所有字母单独存入栈中,所以出栈等价于对字母反序操作。(或者可以用数组存储字母并反序数组)然后,遍历 s 的所有字符,如果是字母我们就选择栈顶元素输出。

  • 双指针:一个接一个输出 s 的所有字符。当遇到一个字母时,我们希望找到逆序遍历字符串的下一个字母。所以我们这么做:维护一个指针 j 从后往前遍历字符串,当需要字母时就使用它。

java 复制代码
class Solution {
    public String reverseOnlyLetters(String S) {
    
        Stack<Character> letters = new Stack();
        for (char c: S.toCharArray())
            if (Character.isLetter(c))
                letters.push(c);

        StringBuilder ans = new StringBuilder();
        for (char c: S.toCharArray()) {
            if (Character.isLetter(c))
                ans.append(letters.pop());
            else
                ans.append(c);
        }

        return ans.toString();
    }
}
java 复制代码
class Solution {
    public String reverseOnlyLetters(String S) {
       if (S == null || S.length() == 0) {
            return S;
        }
        StringBuilder ans = new StringBuilder();
        int j = S.length() - 1;
        for (int i = 0; i < S.length(); ++i) {
            if (Character.isLetter(S.charAt(i))) {
                while (!Character.isLetter(S.charAt(j)))
                    j--;
                ans.append(S.charAt(j--));
            } else {
                ans.append(S.charAt(i));
            }
        }
        return ans.toString();
    }
}

反转字符串里的单词

给你一个字符串 s ,逐个反转字符串中的所有 单词

单词 是由非空格字符组成的字符串 。s 中使用至少一个空格将字符串中的 单词 分隔开。

请你返回一个反转 s 中单词顺序并用单个空格相连的字符串

说明:

  • 输入字符串 s 可以在前面、后面或者单词间包含多余的空格。

  • 反转后单词间应当仅用一个空格分隔。

  • 反转后的字符串中不应包含额外的空格。

示例1:

输入:s = "the sky is blue"

输出:"blue is sky the"

示例2:

输入:s = "hello world"

输出:"world hello"

解释:输入字符串可以在前面或者后面包含多余的空格,但是反转后的字符不能包括。

复制代码
java 复制代码
public String reverseWords(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        // 除去开头和末尾的空白字符,记住这个操作
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
复制代码
java 复制代码
class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = trimSpaces(s);

        // 翻转字符串
        reverse(sb, 0, sb.length() - 1);

        // 翻转每个单词
        reverseEachWord(sb);

        return sb.toString();
    }

    public StringBuilder trimSpaces(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        // 将字符串间多余的空白字符去除
        StringBuilder sb = new StringBuilder();
        while (left <= right) {
            char c = s.charAt(left);

            if (c != ' ') {
                sb.append(c);
            } else if (sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }

            ++left;
        }
        return sb;
    }

    public void reverse(StringBuilder sb, int left, int right) {
        while (left < right) {
            char tmp = sb.charAt(left);
            sb.setCharAt(left++, sb.charAt(right));
            sb.setCharAt(right--, tmp);
        }
    }

    public void reverseEachWord(StringBuilder sb) {
        int n = sb.length();
        int start = 0, end = 0;

        while (start < n) {
            // 循环至单词的末尾
            while (end < n && sb.charAt(end) != ' ') {
                ++end;
            }
            // 翻转单词
            reverse(sb, start, end - 1);
            // 更新start,去找下一个单词
            start = end + 1;
            ++end;
        }
    }
}

验证回文串

给定一个字符串,找到它的第一个不重复的字符,并返回它的索引。如果不存在,则返回 -1。

  • 在第一次遍历时,我们使用哈希映射统计出字符串中每个字符出现的次数。在第二次遍历时,我们只要遍历到了一个只出现一次的字符,那么就返回它的索引,否则在遍历结束后返回 -1。
java 复制代码
public int firstUniqChar(String s) {
       if (s == null || s.length() == 0) {
           return 0;
       }
       Map<Character, Integer> frequency = new HashMap<Character, Integer>();
       for (int i = 0; i < s.length(); ++i) {
           char ch = s.charAt(i);
           frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
       }
       for (int i = 0; i < s.length(); ++i) {
           if (frequency.get(s.charAt(i)) == 1) {
               return i;
           }
       }
       return -1;
   }

判断是否互为字符重排

给定两个字符串 s1 和 s2,请编写一个程序,确定其中一个字符串的字符重新排列后,能否变成另一个字符串。

  • 将两个字符串全部从小到大或者从大到小排列,然后再逐个位置比较

  • 我们可以记录出现的次数,如果一个字符串经过重新排列后,能够变成另外一个字符串,那么它们的每个不同字符的出现次数是相同的。如果出现次数不同,那么表示两个字符串不能够经过重新排列得到。

java 复制代码
public boolean checkPermutation(String s1, String s2) {
        // 将字符串转换成字符数组
        char[] s1Chars = s1.toCharArray();
        char[] s2Chars = s2.toCharArray();
        // 对字符数组进行排序
        Arrays.sort(s1Chars);
        Arrays.sort(s2Chars);
        // 再将字符数组转换成字符串,比较是否相等
        return new String(s1Chars).equals(new String(s2Chars));
    }
复制代码
java 复制代码
public boolean checkPermutation(String s1, String s2) {
        if (s1.length() != s2.length()) {
            return false;
        }
        char[] s1Chars = s1.toCharArray();
        Map<Character, Integer> s1Map = getMap(s1);
        Map<Character, Integer> s2Map = getMap(s2);
        for (char s1Char : s1Chars) {
            if (!s2Map.containsKey(s1Char) || (int)s2Map.get(s1Char) != (int)s1Map.get(s1Char)) {
                return false;
            }
        }
        return true;
    }

    // 统计指定字符串str中各字符的出现次数,并以Map的形式返回
    private Map<Character, Integer> getMap(String str) {
        Map<Character, Integer> map = new HashMap<>();
        char[] chars = str.toCharArray();
        for (char aChar : chars) {
            map.put(aChar, map.getOrDefault(aChar, 0) + 1);
        }
        return map;
    }

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀,返回空字符串 ""。

示例1:

输入:strs = ["flower","flow","flight"]

输出:"fl"

示例2:

输入:strs = ["dog","racecar","car"]

输出:""

解释:输入不存在公共前缀。

  • 竖着比较,每前进一个位置就比较各个串,看是不是都是相等的,只要在某一轮遇到一个不相等的,那么就结束。

  • 横着比较,借鉴归并的思想,先两两一组找fix,然后将找到的fix再两两归并。依次遍历字符串数组中的每个字符串,对于每个遍历到的字符串,更新最长公共前缀(其实就是看是否要缩短,一定不会变长),当遍历完所有的字符串以后,即可得到字符串数组中的最长公共前缀。如果在尚未遍历完所有的字符串时,最长公共前缀已经是空串,则最长公共前缀一定是空串,因此不需要继续遍历剩下的字符串,直接返回空串即可。

复制代码
java 复制代码
public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) {
            return "";
        }
        int length = strs[0].length();
        int count = strs.length;
        for (int i = 0; i < length; i++) {
            char c = strs[0].charAt(i);
            for (int j = 1; j < count; j++) {
                if (i == strs[j].length() || strs[j].charAt(i) != c) {
                    return strs[0].substring(0, i);
                }
            }
        }
        return strs[0];
    
复制代码
java 复制代码
public String longestCommonPrefix(String[] strs) {
    if (strs == null || strs.length == 0) {
        return "";
    }
    String prefix = strs[0];
    int count = strs.length;
    for (int i = 1; i < count; i++) {
        prefix = longestCommonPrefix(prefix, strs[i]);
        if (prefix.length() == 0) {
            break;
        }
    }
    return prefix;
}

public String longestCommonPrefix(String str1, String str2) {
    int length = Math.min(str1.length(), str2.length());
    int index = 0;
    while (index < length && str1.charAt(index) == str2.charAt(index)) {
        index++;
    }
    return str1.substring(0, index);
}

字符串压缩问题

给你一个字符数组 chars ,请使用下述算法压缩:

从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 :

  • 如果这一组长度为 1 ,则将字符追加到 s 中。

  • 否则,需要向 s 追加字符,后跟这一组的长度。压缩后得到的字符串 s 不应该直接返回 ,需要转储到字符数组 chars 中。需要注意的是,如果组长度为 10 或 10 以上,则在 chars 数组中会被拆分为多个字符。

请在 修改完输入数组后 ,返回该数组的新长度。你必须设计并实现一个只使用常量额外空间的算法来解决此问题。

复制代码
java 复制代码
示例1:
输入:chars = ["a","a","b","b","c","c","c"]
输出:返回 6 ,输入数组的前 6 个字符应该是:["a","2","b","2","c","3"]
解释:
"aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。

示例2:
输入:chars = ["a"]
输出:返回 1 ,输入数组的前 1 个字符应该是:["a"]
解释:
没有任何字符串被替代。

示例3:
输入:chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
输出:返回 4 ,输入数组的前 4 个字符应该是:["a","b","1","2"]。
解释:
由于字符 "a" 不重复,所以不会被压缩。"bbbbbbbbbbbb" 被 "b12" 替代。
注意每个数字在数组中都有它自己的位置。
  • 可以使用两个指针分别标志我们在字符串中读和写的位置,还要一个指针left用来标记重复字段的开始位置。read指针不断向前读取,每次当读指针 read 移动到某一段连续相同子串的最右侧,我们就在写指针 write 处依次写入该子串对应的字符和子串长度即可。当读指针read 位于字符串的末尾,或读指针read 指向的字符不同于下一个字符时,我们就认为读指针read 位于某一段连续相同子串的最右侧。该子串对应的字符即为读指针 read 指向的字符串。我们使用变量 left 记录该子串的最左侧的位置,这样子串长度即为 read−left+1。这里还有一个问题,就是长度可能超过10,因此还要实现将数字转化为字符串写入到原字符串的功能。这里我们采用短除法将子串长度倒序写入原字符串中,然后再将其反转即可。
java 复制代码
public int compress(char[] chars) {
        int n = chars.length;
        int write = 0, left = 0;
        for (int read = 0; read < n; read++) {
            if (read == n - 1 || chars[read] != chars[read + 1]) {
                chars[write++] = chars[read];
                int num = read - left + 1;
                if (num > 1) {
                    int anchor = write;
                    while (num > 0) {
                        chars[write++] = (char) (num % 10 + '0');
                        num /= 10;
                    }
                    reverse(chars, anchor, write - 1);
                }
                left = read + 1;
            }
        }
        return write;
    }

    public void reverse(char[] chars, int left, int right) {
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
    }
}
相关推荐
一路向北North16 分钟前
IDEA加载项目时依赖无法更新
java·ide·intellij-idea
小森77671 小时前
(三)机器学习---线性回归及其Python实现
人工智能·python·算法·机器学习·回归·线性回归
振鹏Dong1 小时前
超大规模数据场景(思路)——面试高频算法题目
算法·面试
uhakadotcom1 小时前
Python 与 ClickHouse Connect 集成:基础知识和实践
算法·面试·github
uhakadotcom1 小时前
Python 量化计算入门:基础库和实用案例
后端·算法·面试
小萌新上大分1 小时前
SpringCloudGateWay
java·开发语言·后端·springcloud·springgateway·cloudalibaba·gateway网关
uhakadotcom2 小时前
使用 Python 与 BigQuery 进行交互:基础知识与实践
算法·面试
uhakadotcom2 小时前
使用 Hadoop MapReduce 和 Bigtable 进行单词统计
算法·面试·github
XYY3692 小时前
前缀和 一维差分和二维差分 差分&差分矩阵
数据结构·c++·算法·前缀和·差分
直视太阳2 小时前
springboot+easyexcel实现下载excels模板下拉选择
java·spring boot·后端