字符串

1. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:

输入: ["flower","flow","flight"]
输出: "fl"
示例 2:

输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/array-and-string/ceda1/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

解题思路：字符串数组排序。对于排好序的字符串数组，只要判断第一个和最后一个前缀相等即可。

class Solution {
　　public String longestCommonPrefix(String[] strs) {
　　if(strs.length == 0){
　　　　return "";
　　}
　　if(strs.length == 1) {
　　　　return strs[0];
　　}
　　Arrays.sort(strs);
　　String first = strs[0];
　　String last = strs[strs.length - 1];

　　StringBuilder sb = new StringBuilder();
　　for(int i = 0; i < first.length(); i++) {
　　　　if(first.charAt(i) == last.charAt(i)) {
　　　　　　sb.append(first.charAt(i));
　　　　　　continue;
　　　　}
　　　　break;
　　}

　　return sb.toString();

　　}
}

 

2. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 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"]

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/array-and-string/cacxi/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

class Solution {
    public void reverseString(char[] s) {
        if(s == null || s.length < 2) {
            return;
        }
        int start = 0;
        int end = s.length - 1;

        while(start < end) {
            char temp = s[start];
            s[start] = s[end];
            s[end] = temp;

            start++;
            end--;
        }
    }
}

 

2. 翻转字符串里的单词

给定一个字符串，逐个翻转字符串中的每个单词。

说明：

无空格字符构成一个 单词 。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
 

示例 1：

输入："the sky is blue"
输出："blue is sky the"
示例 2：

输入："  hello world!  "
输出："world! hello"
解释：输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入："a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
示例 4：

输入：s = " Bob Loves Alice "
输出："Alice Loves Bob"
示例 5：

输入：s = "Alice does not even like bob"
输出："bob like even not does Alice"

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/array-and-string/crmp5/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解题思路：把字符串去掉前后空格后，按空格进行单词分割。然后把字符串数组的前半部分和后半部分进行交换，再转换成一个字符串。

class Solution {
    public String reverseWords(String s) {
        if(s == null || s.trim().length() == 0) {
            return "";
        }
        String[] words = s.trim().split("\\s+");
        if(words.length == 1) {
            return s.trim();
        }

        int right = words.length - 1;

        for(int i = 0; i < words.length/2; i++) {
            String temp = words[i];
            words[i] = words[right];
            words[right] = temp;
            right--;
        }

       return String.join(" ", words);
    }
}
 
3. 最长回文子串

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

示例 1：

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

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

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/array-and-string/conm7/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

方法一：中心扩展算法：

从字符向两边扩散查找，找到不同就停止。

class Solution {
    public String longestPalindrome(String s) {
        if(s == null || s.length() < 1) {
            return "";
        }
        int start = 0;
        int end = 0;

        for(int i = 0; i < s.length() - 1; i++) {
            int len1 = expandAndAround(s, i, i); // 长度为奇数位
            int len2 = expandAndAround(s, i, i+1); //长度为偶数位
            int len = Math.max(len1, len2);

            if(len > end - start + 1) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);

    }

    private int expandAndAround(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }

        return right - left - 1;
    }
}
 
 4. 反转字符串中的单词 III

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

 

示例：

输入："Let's take LeetCode contest"
输出："s'teL ekat edoCteeL tsetnoc"
 

提示：

在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/array-and-string/c8su7/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

1.  把字符串转换为字符数组。通过对字符串一次循环，找出单词，进行字符交换。

class Solution {
    public String reverseWords(String s) {
        char[] chars = s.toCharArray();
        int begin = 0;

        for(int i = 0; i < chars.length; i++) {
            if(chars[i] == ' '){
                reverseChars(chars, begin, i - 1);
                begin = i + 1;  
            }
            if(i == chars.length - 1){
                reverseChars(chars, begin, i);
            }
        }

        return String.valueOf(chars);
    }

    private void reverseChars(char[] chars, int begin, int end) {
        while(begin < end) {
            char temp = chars[begin];
            chars[begin] = chars[end];
            chars[end] = temp;
            begin++;
            end--;
        }
    }
}
 
5. 字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
["ate","eat","tea"],
["nat","tan"],
["bat"]
]
说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/hash-table/xxo631/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解题思路: 字母异位是同一组，可以把这些字符排序后作为一个key，作为一个组的key. 然后进行统计。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> strMap = new HashMap<>();
        for(String str : strs) {
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String temp = String.valueOf(chars);
            List<String> list;
            if(strMap.get(temp) == null) {
                list = new ArrayList<>();        
            } else {
                list = strMap.get(temp);
            }
            list.add(str);
            strMap.put(temp,list);
        }

        return strMap.values().stream().collect(Collectors.toList());
    }
}

 

6. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

 

示例 1:

输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
  请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:

输入: s = ""
输出: 0

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/hash-table/xxnrdi/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解题思路: 使用滑动窗口加hashMap，移动一位记一个长度。当同一字符出现第二次时，从start开始收缩窗口，hashMap把这些缩减的字符数减掉。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s.isEmpty()){
            return 0;
        }
        int maxLength = 1;
        int start = 0;
        Map<Character,Integer> charMap = new HashMap<>();

        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            charMap.put(ch, charMap.getOrDefault(ch,0) + 1);
            
            if(charMap.get(ch) <= 1) {
                maxLength = Math.max(maxLength, i - start + 1);         
                continue;
            } 
            while(charMap.get(ch) > 1 ) {
                char temp = s.charAt(start);
                charMap.put(temp, charMap.get(temp) - 1);           
                start++;    
            }
        }
        return maxLength;
    }
}
 
 

给你一个非空的字符串 s 和一个整数 k，你要将这个字符串中的字母进行重新排列，使得重排后的字符串中相同字母的位置间隔距离至少为 k。

所有输入的字符串都由小写字母组成，如果找不到距离至少为 k 的重排结果，请返回一个空字符串 ""。

示例 1：

输入: s = "aabbcc", k = 3
输出: "abcabc"
解释: 相同的字母在新的字符串中间隔至少 3 个单位距离。
示例 2:

输入: s = "aaabc", k = 3
输出: ""
解释: 没有办法找到可能的重排结果。
示例 3:

输入: s = "aaadbbcc", k = 2
输出: "abacabcd"
解释: 相同的字母在新的字符串中间隔至少 2 个单位距离。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rearrange-string-k-distance-apart
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 
解题思路：统计字符串中每个字符出现的次数，并且进行从大到小的排序，此处用PriorityQueue进行排序。个数出现最多的先排列。排过的字符放入队列，当队列长度达到间隔长度，排过的字符就可以继续排队。
 

class Solution {
　　public String combineChars(String input, int interval) {
　　　　if(interval <= 1) {
　　　　　　return input;
　　　　}

　　　　HashMap<Character, Integer> charMap = new HashMap<>();
　　　　PriorityQueue<Map.Entry<Character, Integer>> maxQueue = new PriorityQueue<>(
　　　　　　(b1,b2) -> {
　　　　　　　　return b2.getValue() - b1.getValue();
　　　　　　}
　　　　);

　　　　for(char ch : input.toCharArray()) {
　　　　　　charMap.put(ch, charMap.getOrDefault(ch, 0) + 1);
　　　　}

　　　　maxQueue.addAll(charMap.entrySet());

　　　　LinkedList<Map.Entry<Character, Integer>> queue = new LinkedList<>();
　　　　StringBuilder sb = new StringBuilder();

　　　　while(!maxQueue.isEmpty()) {

　　　　　　Map.Entry<Character, Integer> entry = maxQueue.poll();
　　　　　　sb.append(entry.getKey());
　　　　　　entry.setValue(entry.getValue() - 1);
　　　　　　queue.add(entry);

　　　　　　if(queue.size() == interval) {

　　　　　　　　Map.Entry<Character,Integer> tempEntry = queue.poll();
　　　　　　　　　　if(tempEntry.getValue() > 0) {
　　　　　　　　　　　　maxQueue.add(tempEntry);
　　　　　　　　　　}
　　　　　　}

　　　　}

　　　　return sb.length() == input.length() ? sb.toString() : "";

　　}
}

 

7  电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

 

 

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

解题思路： 使用递归加回溯来解决。

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        if(digits == null || digits.length() == 0){
            return result;
        }

        Map<Character, String> phoneMap = new HashMap<>();
        phoneMap.put('2',"abc");
        phoneMap.put('3',"def");
        phoneMap.put('4',"ghi");
        phoneMap.put('5',"jkl");
        phoneMap.put('6',"mno");
        phoneMap.put('7',"pqrs");
        phoneMap.put('8',"tuv");
        phoneMap.put('9',"wxyz");

        combineChar(digits, phoneMap, result, 0, new StringBuilder());

        return result;
    }

    private void combineChar(String digits, Map<Character, String> phoneMap, List<String> result, int index, StringBuilder combineStr) {
        if( index == digits.length()){
            result.add(combineStr.toString());
            return;
        }

        char digit = digits.charAt(index);
        String letters = phoneMap.get(digit);

        for(int i = 0; i < letters.length(); i++){
           combineStr.append(letters.charAt(i));
           combineChar(digits,phoneMap,result, index + 1, combineStr);
           combineStr.deleteCharAt(index);
        }
    }
}

8   复原IP地址

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是 有效的 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效的 IP 地址。

 

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：

输入：s = "0000"
输出：["0.0.0.0"]
示例 3：

输入：s = "1111"
输出：["1.1.1.1"]
示例 4：

输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]
示例 5：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/restore-ip-addresses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

解题思路: 递归加剪枝

public class ValidIP {

    public List<String> restoreIpAddresses(String s) {
        List<String> result = new ArrayList<String>();
        if(s.length() < 4 && s.length() > 12) {
            return result;
        }

        buildVoidIPs(s, result, 0, "", 0);

        return result;
    }

    private void buildVoidIPs(String s, List<String> result, int index, String ip, int dotCount) {
        if(dotCount >= 4  && index < s.length()) {
            return;
        }
        if(index >= s.length()) {
            if(isValidIP(ip)) {
                result.add(ip);
            }
            return;
        }
        if(!ip.isEmpty()) {
            ip += ".";
        }

        for(int i = index; i < index + 3 && i < s.length(); i++) {
            char temp = s.charAt(i);
            if(!Character.isDigit(temp)) {
                return;
            }
            ip += temp;
            if(temp == '0' && i == index) {
                buildVoidIPs(s, result, i + 1, ip, dotCount + 1);
                break;
            }

            buildVoidIPs(s, result, i + 1, ip, dotCount + 1);
        }
    }

    private boolean isValidIP(String ipStr) {
        String[] ints = ipStr.split("\\.");
        if(ints.length != 4) {
            return false;
        }

        for(int i = 0; i < ints.length; i++) {
            int temp = Integer.valueOf(ints[i]);
            if(temp > 255) {
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        String ip = "25525511135";
        ValidIP validIP = new ValidIP();
        validIP.restoreIpAddresses(ip);
    }
}


9. 最大数

给定一组非负整数 nums，重新排列它们每个数字的顺序（每个数字不可拆分）使之组成一个最大的整数。

注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/largest-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

解题思路：字符串排序，从大到小排序，如果两个字符串有相同的前缀，用a+b 和 b +a排序。

 

class Solution {
    public String largestNumber(int[] nums) {
        if(nums.length == 1) {
            return String.valueOf(nums[0]);
        }
        String[] numStr = new String[nums.length];
        for(int i = 0 ; i < numStr.length; i++) {
            numStr[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(numStr, (num1, num2) ->  {
            int res = (num1 + num2).compareTo(num2 + num1);
            return -res;
        } );
        StringBuilder sb = new StringBuilder();

        for(String num : numStr) {
            sb.append(num);
        }
        if(sb.charAt(0) == '0') {
            return "0";
        }
        return sb.toString();
    }
}
 

1647. 字符频次唯一的最小删除次数

如果字符串 s 中 不存在 两个不同字符 频次 相同的情况，就称 s 是 优质字符串 。

给你一个字符串 s，返回使 s 成为 优质字符串 需要删除的 最小 字符数。

字符串中字符的 频次 是该字符在字符串中的出现次数。例如，在字符串 "aab" 中，'a' 的频次是 2，而 'b' 的频次是 1 。

 

示例 1：

输入：s = "aab"
输出：0
解释：s 已经是优质字符串。

示例 2：

输入：s = "aaabbbcc"
输出：2
解释：可以删除两个 'b' , 得到优质字符串 "aaabcc" 。
另一种方式是删除一个 'b' 和一个 'c' ，得到优质字符串 "aaabbc" 。

示例 3：

输入：s = "ceabaacb"
输出：2
解释：可以删除两个 'c' 得到优质字符串 "eabaab" 。
注意，只需要关注结果字符串中仍然存在的字符。（即，频次为 0 的字符会忽略不计。）
 解题思路: 统计每个字符出现的次数，然后按次数排序。然后把字符进行比较删除，即可。
 public int minDeletions(String s) {
        int[] chars = new int[26];

        for(char ch : s.toCharArray()) {
            chars[ch - 'a']++;
        }

        Arrays.sort(chars);
        int count = 0;

        for(int i =  chars.length - 1; i > 0; i--) {
            if(chars[i-1] == 0) {
                break;
            }
            if(chars[i] > chars[i-1]) {
                continue;
            }
            while(chars[i-1] >= chars[i] && chars[i-1] > 0) {
                chars[i-1]--;
                count++;
            }
        }
        return count;

    }


 























            

            
posted @ 
2020-12-24 16:49 
闪闪的星光 
阅读(255) 
评论(0) 
 
收藏 
举报