LeetCode基础算法-字符串

字数 898阅读 94

LeetCode基础算法-字符串

LeetCode 算法 字符串


1. 翻转字符串

编写一个函数,其作用是将输入的字符串反转过来。

解题思路:

  1. 双指针法。
  2. low = 0 ,high = 字符串长度-1,low与high逐步逼近。
public String reverseString(String s) {
        if (s == null) {
            return null;
        }
        int low = 0;
        int high = s.length() - 1;
        char temp;
        char[] chars = s.toCharArray();
        while (low < high) {
            temp = chars[low];
            chars[low] = chars[high];
            chars[high] = temp;
            low++;
            high--;
        }
        return new String(chars);
    }


2. 颠倒整数

给定一个 32 位有符号整数,将整数中的数字进行反转。

假设我们的环境只能存储 32 位有符号整数,其数值范围是 [−231, 231 − 1]。根据这个假设,如果反转后的整数溢出,则返回 0。

解题思路:

  1. 不断求余+不断求商。
    public int reverse(int x) {
        long result = 0;
        while (x != 0) {
            result = result * 10 + x % 10;
            x /= 10;
        }

        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            return 0;
        }
        return (int) result;
    }

3. 字符串中的第一个唯一字符

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

注意事项:您可以假定该字符串只包含小写字母。

解题思路:

  1. 从a-z逐个遍历,查看在S中的indexOf与lastIndexOf的值是否相同。
  2. 最多遍历26次,如果对S的字符逐个遍历,则效率较低,因为至少需要遍历S长度遍。
    public int firstUniqChar(String s) {
        int result = -1;
        int index;
        for (char ch = 'a'; ch <= 'z'; ch++) {
            index = s.indexOf(ch);
            if (index != -1 && index == s.lastIndexOf(ch)) {
                result = result != -1 ? Math.min(index, result) : index;
            }
        }
        return result;
    }

4. 异位词

给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的一个字母异位词。

你可以假设字符串只包含小写字母。

解题思路:

  1. 若两个词为异位词,那么每个zi字符串中每个字符出现的次数必定相同。
  2. 两个数组,分别收集两个字符串中字符出现的次数,并比较同一个字符出现的次数是否相同。
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
            return false;
        }
        int[] sCounter = new int[26];
        int[] tCounter = new int[26];

        for (int i = 0; i < s.length(); i++) {
            sCounter[s.charAt(i) - 'a']++;
            tCounter[t.charAt(i) - 'a']++;
        }

        for (int i = 0; i < 26; i++) {
            if (sCounter[i] != tCounter[i]) {
                return false;
            }

        }
        return true;
  
    }

5. 字符串转整数

实现 atoi,将字符串转为整数。

在找到第一个非空字符之前,需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号,选取该符号,并将其与后面尽可能多的连续的数字组合起来,这部分字符即为整数的值。如果第一个非空字符是数字,则直接将其与之后连续的数字字符组合起来,形成整数。

字符串可以在形成整数的字符后面包括多余的字符,这些字符可以被忽略,它们对于函数没有影响。

当字符串中的第一个非空字符序列不是个有效的整数;或字符串为空;或字符串仅包含空白字符时,则不进行转换。

若函数不能执行有效的转换,返回 0。

说明:

假设我们的环境只能存储 32 位有符号整数,其数值范围是 [−231, 231 − 1]。如果数值超过可表示的范围,则返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

public int myAtoi(String str) {
        if (str == null) {
            return 0;
        }
        str = str.trim();
        char[] ch = str.toCharArray();
        int positive = 1;
        double result = 0;
        char num;
        for (int i = 0; i < ch.length; i++) {
            num = ch[i];
            if (i == 0) {
                if (num != '+' && num != '-' && Character.isDigit(num) == false) {
                    return 0;
                }
                if (num == '+') {
                    positive = 1;
                    continue;
                }
                if (num == '-') {
                    positive = -1;
                    continue;
                }
                if (Character.isDigit(num)) {
                    result = result * 10 + Integer.parseInt(num + "");
                }
            } else {
                if (Character.isDigit(num)) {
                    result = result * 10 + Integer.parseInt(num + "");
                } else {
                    break;
                }
            }
        }
        result *= positive;
        if (result > Integer.MAX_VALUE) {
            return Integer.MAX_VALUE;
        }
        if (result < Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        }
        return (int) result;
    }


6. 实现strStr

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回 -1。

 public int strStr(String haystack, String needle) {
        if (needle == null || needle.isEmpty()) {
            return 0;
        }
        if (haystack.length() < needle.length()) {
            return -1;
        }

        int i, j;
        int[] next = getNext(needle);
        for (i = 0, j = 0; i < haystack.length(); i++) {
            while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
                j = next[j - 1];
            }

            if (haystack.charAt(i) == needle.charAt(j)) {
                j++;
            }

            if (j == needle.length()) {
                return i - j + 1;
            }

        }

        return -1;

    }

    private int[] getNext(String str) {
        char[] strKey = str.toCharArray();
        int[] next = new int[str.length()];
        next[0] = 0;
        int index = 1;
        for (index = 1; index < str.length(); index++) {
            int k = next[index - 1];
            while (strKey[index] != strKey[k] && k != 0) {
                k = next[k - 1];
            }
            if (strKey[index] == strKey[k]) {
                next[index] = k + 1;
            } else {
                next[index] = 0;
            }

        }
        return next;
    }


7. 最长回文子串

给定一个字符串 s,找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

示例 1:

输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。
示例 2:

输入: "cbbd"
输出: "bb"

public String longestPalindrome(String s) {
        // 1. 使用动态规划
        // dp[i][j]代表索引i到索引j是否为回文串
        // dp[i][]:1.i==j,true;2.s[i]=[j]&&dp[i+1][j-1]
        boolean[][] dp = new boolean[s.length()][s.length()];
        int start = 0;
        int maxLength = 1;
        for (int i = 0; i < s.length(); i++) {
            for (int j = 0; j <= i; j++) {
                if (i - j < 2) {
                    dp[j][i] = s.charAt(i) == s.charAt(j);
                } else {
                    dp[j][i] = (s.charAt(i) == s.charAt(j)) && dp[j + 1][i - 1];
                }
                if (dp[j][i] && maxLength < (i - j + 1)) {
                    maxLength = i - j + 1;
                    start = j;
                }

            }
        }
        return s.substring(start, maxLength + start);
        
        // 2.使用Manacher算法
        // 在每个字符的前后插入#,分别计算每个字符的最大回文字符串长度。
        // 找出最大长度,然后截取字符串
        int sLength = s.length();
        int helperLength = 2 * sLength + 1;
        char[] helpers = new char[helperLength];
        Arrays.fill(helpers, '#');
        for (int i = 0, j = 1; i < s.length(); i++, j += 2) {
            helpers[j] = s.charAt(i);
        }
        int[] palindromeNums = new int[helperLength];
        palindromeNums[0] = 0;
        palindromeNums[helperLength - 1] = 0;
        for (int i = 1; i < helperLength - 1; i++) {
            int length = 0;
            int left = i - 1;
            int right = i + 1;
            while (left >= 0 && right < helperLength) {
                if (helpers[left] == helpers[right]) {
                    left--;
                    right++;
                    length++;
                } else {
                    break;
                }
            }
            if (length != 0) {
                length = length + 1;
            }
            palindromeNums[i] = length;
        }

        int maxLength = 0;
        int index = 0;
        for (int i = 1; i < helperLength - 1; i++) {
            if (palindromeNums[i] > maxLength) {
                maxLength = palindromeNums[i];
                index = i;
            }
        }
        if (maxLength == 0) {
            return "";
        } else {
            int left = index - maxLength + 1;
            int right = index + maxLength - 1;
            StringBuilder sBuilder = new StringBuilder();
            for (int i = left; i <= right; i++) {
                if (helpers[i] != '#') {
                    sBuilder.append(helpers[i]);
                }
            }
            return sBuilder.toString();
        }
    }

推荐阅读更多精彩内容