搞定字符串类面试题-Palindrome

最新推荐文章于 2024-07-18 01:42:44 发布
最新推荐文章于 2024-07-18 01:42:44 发布
阅读量131 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://juejin.im/post/5c51823ce51d4556940c282a
版权

409 Longest Palindrome[Easy]

  • 题目: 给出一个字符串,求这个字符串能够组合出来的最长回文串
  • 思路: 不能直接用一个hash数组来做记录奇偶数,因为会出现多个总数为奇数的字符和一个总数为奇数的长字符。
  • 还要进行判断建一个HashSet需要挑出最长的奇数字符串 没有将奇数字符串中的成对出现的偶数部分加入到最后的结果中。
class Solution {
    public int longestPalindrome(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        HashSet<Character> set = new HashSet<>();
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (set.contains(s.charAt(i))) {
                set.remove(s.charAt(i));
                count++;
            } else {
                set.add(s.charAt(i));
            }
        }
        if (set.isEmpty()) {
            return count * 2;
        }
        return count * 2 + 1;
    }
}
复制代码

9. Palindrome Number[Easy]

  • 题目: 判断一个整数是不是回文的
  • 思路: 先将整数转为一个字符串数组，两个指针从两端向中间走
class Solution {
    public boolean isPalindrome(int x) {
        String nums = Integer.toString(x);
        int left = 0;
        int right = nums.length() - 1;
        while (left < right) {
            if (nums.charAt(left) != nums.charAt(right)) {
                return false;
            } else {
                left++;
                right--;
            }
        }
        return true;
    }
}
复制代码

234. Palindrome Linked List[Easy]

  • 题目: 判断一个单向链表是否是回文串
  • 思路: 复制一个相同的链表,进行一个reverse操作，然后用两个指针从两个链表的头分别向后移动并逐个比对 O(n)的空间复杂度 O(n)的时间复杂度。 优化:先用快慢指针找到该链表的中点,将后半段reverse，然后用两个指针同向移动
class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        if (fast != null) { //这里需要做一个奇偶的判断,如果fast不为null,那么slow需要向前移动一位，跳过中间值
            slow = slow.next;
        }
        slow = reverse(slow);
        ListNode left = head;
        ListNode right = slow;
        while (right != null) {
            if (left.val != right.val) {
                return false;
            }
            left = left.next;
            right = right.next;
        }
        return true;
    }
    
    private ListNode reverse(ListNode node) {
        ListNode prev = null;
        ListNode curr = node;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}
复制代码

49. Group Anagrams[Medium]

  • 思路: 用一个hashtable来存 数组来存一个集合？ 如何能找到不同字母组合的一致性？ 只需要包含相同的字母即可, 顺序没有关系
  • 需要的是一个flag来做记录 两个选择: 1. 类似a1b2c3的结构 2.直接排序得到有序结果
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) {
            return new ArrayList<>();
        }
        List<List<String>> res = new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();
        int[] count = new int[26];
        
        for (String str : strs) {
            Arrays.fill(count, 0);
            for (char c : str.toCharArray()) {
                count[c - 'a']++;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 26; i++) {
                if (count[i] != 0) {
                    sb.append((char)(i + 'a')).append(count[i]);
                }
            }
            String flag = sb.toString();
            if (!map.containsKey(flag)) {
                map.put(flag, new ArrayList<>());
            }
            map.get(flag).add(str);
        }
        return new ArrayList<>(map.values());
    }
}
复制代码

266.Palindrome Permutation[Easy]

  • 题目:给出一个字符串，判断该字符串的permutation能否组成给一个回文串
  • 思路: 开一个长度256的数组来记录每个字符出现的次数,最多仅允许存在一个出现奇数次的字符
class Solution {
    public boolean canPermutePalindrome(String s) {
        if (s.length() == 0) {
            return true;
        }
        boolean oneOdd = false;
        int[] counts = new int[256];
        for (int i = 0; i < s.length(); i++) {
            counts[s.charAt(i)]++; //这里直接用s.charAt(i)作为ASCII编码
        }
        
        for (int k = 0; k < counts.length; k++) {
            if (counts[k] % 2 != 0) {                
                if (oneOdd == true) {
                    return false;
                }
                else {
                    oneOdd = true;
                }
            }
        }
        
        return true;
    }
}
复制代码

267. Palindrome PermutationII [Medium]

  • 思路: Permutation 如何找到？ DFS + backtracking, 回文串的permuration是通过两个指针进行简单的镜像对称来实现的 在找到的所有的permutation当中判断出来哪些是Palindrome放到res当中。效率太低。

需要判断的是字符串的奇偶性, 用一个oneOdd变量来做标记，如果是奇数个, 最中间一定是一个单字符, 双指针的起点是i-１和i+１,如果是偶数个, 起点为i和i + 1

public class Solution {
    public List<String> generatePalindromes(String s) {
        int[] hash = new int[256];
        for(int i = 0; i < s.length(); i++){
            int index = (int) s.charAt(i);
            hash[index] ++;
        }
        char center = '.';
        boolean oneOdd = false;
        for(int i = 0; i < 256; i++){
            if(hash[i] % 2 == 0){
                continue;
            } else {
                if(oneOdd) return new ArrayList<String>(); //奇数字符多于一个直接return空字符
                oneOdd = true;
                center = (char) i;
                hash[i] --;
            }
        }

        char[] array = new char[s.length()];
        List<String> list = new ArrayList<String>();
        if(oneOdd) {
            array[s.length() / 2] = center;
            dfs(list, array, hash, s.length() / 2 - 1, s.length() / 2 + 1);
        } else {
            dfs(list, array, hash, s.length() / 2 - 1, s.length() / 2);    
        }

        return list;
    }

    private void dfs(List<String> list, char[] array, int[] hash, int left, int right){
        if(left < 0 || right >= array.length){
            list.add(new String(array));
            return;
        }
        for(int i = 0; i < 256; i++){
            if(hash[i] <= 0) continue;

            array[left] = (char) i;
            array[right] = (char) i;
            hash[i] -= 2;

            dfs(list, array, hash, left - 1, right + 1);

            array[left] = '.';
            array[right] = '.';
            hash[i] += 2;
        }
    }
}
复制代码

5. Longest Palindromic Substring[Medium]

  • 题目: 找出最长的回文子串
  • 思路: 中心点枚举直接做，写一个得到回文串长度的function, Corner Case是只有一个字符和只有两个字符时的情况。while循环的终点根据指针最后停下的位置来确定。
class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() == 0) {
            return "";
        }
        int start = 0;
        int longest = 0;
        int currLen = 0;
        for (int i = 0; i < s.length(); i++) {
            currLen = calculatePalindromeLength(s, i, i);
            if (currLen > longest) {
                longest = currLen;
                start = i - currLen / 2;
            }
            currLen = calculatePalindromeLength(s, i, i+1);
            if (currLen > longest) {
                longest = currLen;
                start = i - currLen / 2 + 1;
            }
        }
        
        return s.substring(start, start + longest);
    }
    
    private int calculatePalindromeLength(String s, int left, int right) {
        int len = 0;
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            len += left == right ? 1 : 2;
            left--;
            right++;
        }
        return len;
    }
}
复制代码

647. Palindromic Substrings

  • 题目: 给一个字符串，找到所有的回文子串，可以包含重复元素
  • 思路: 和Palindrome Partitioning一样, 找出所有的子串, subset,判断每个子串是否是Palindrome,不需要使用回溯找subset,直接用中心点枚举遍历所有substring即可
public class Solution {
    int count = 0;
    
    public int countSubstrings(String s) {
        if (s == null || s.length() == 0) return 0;
        
        for (int i = 0; i < s.length(); i++) { // i is the mid point
            extendPalindrome(s, i, i); // odd length;
            extendPalindrome(s, i, i + 1); // even length
        }
        
        return count;
    }
    
    private void extendPalindrome(String s, int left, int right) {
        while (left >=0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            count++; 
            left--; 
            right++;
        }
    }
}
复制代码

131. Palindrome Partitioning[Medium]

  • 题目: 给出一个字符串s,求出切分s得到所有的s都是回文串，并将回文串添加到List当中返回
  • 思路: 使用backtracking,找出不同的切分方法
class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>();
        helper(s, res, new ArrayList<>(), 0);
        return res;
    }
    
    public void helper(String s, 
                       List<List<String>> res, 
                       List<String> currList, 
                       int start) {
        if (currList.size() > 0 && start >= s.length()) {
            res.add(new ArrayList(currList));
        }
        for (int i = start; i < s.length(); i++) {
            if (isPalindrome(s, start, i)) {
                currList.add(s.substring(start, i + 1));
                helper(s, res, currList, i + 1);
                currList.remove(currList.size() - 1);
            }
            
        }
    }
    
     private boolean isPalindrome(String s, int i, int j) {
        while (i < j) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
}
复制代码

132. Palindrome Partitioning II

  • 题目: 给出一个字符串s, 求出最少需要切割几次才能够让所有的substring都是回文串
  • 思路:

336. Palindrome Pairs[Hard]

  • 题目: 给出一个String List words，找出所有能够拼接为一个回文串的两个String的index并存在列表之中返回
  • 思路: 如何判断两个String能够拼接为一个回文串？ 如何找到所有的字符串？
    • 如何判断两个String能够拼接为一个回文串？ 先拼接 再直接双指针遍历做判断即可 分类讨论:
      • case 1: blank string, 如果words当中存在回文串,那么该回文串+空串就可以作为一对结果
      • case 2: 对称拼接 s2 是 s1 的reverse
      • case 3: 非对称拼接: s2的一部分和s1的一部分对称 或 s1的一部分和s2的一部分对称
 class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        
        List<List<Integer>> res = new ArrayList<>();
        HashMap<String, Integer> map = new HashMap<>();
        int n = words.length;
        for (int i = 0; i < n; i++) {
            map.put(words[i], i);
        }
        // case 1: blank 
        if (map.containsKey("")) {
            int blankIdx = map.get("");
            for (int i = 0; i < n; i++) {
                if (isPalindrome(words[i])) {
                    if (i == blankIdx) {
                       continue; 
                    }
                    res.add(Arrays.asList(blankIdx, i));
                    res.add(Arrays.asList(i, blankIdx));
                }
            }
        }
        
        // case 2: found the reverse string
        for (int i = 0; i < n; i++) {
            String reverseStr = reverse(words[i]);
            if (map.containsKey(reverseStr)) {
                int found = map.get(reverseStr);
                if (found == i) continue;
                res.add(Arrays.asList(i, found));
            }
        }
        
        //case 3: nonsymmetric 
        for (int i = 0; i < n; i++) {
            String cur = words[i];
            for (int cut = 1; cut < cur.length(); cut++) {
                if (isPalindrome(cur.substring(0, cut))) {
                    String reverseCut = reverse(cur.substring(cut));
                    if(map.containsKey(reverseCut)) {
                        int found = map.get(reverseCut);
                        if (found == i) {
                            continue;
                        }
                        res.add(Arrays.asList(found, i));
                    }
                }
                
                if (isPalindrome(cur.substring(cut))) {
                    String reverseCut = reverse(cur.substring(0, cut));
                    if(map.containsKey(reverseCut)) {
                        int found = map.get(reverseCut);
                        if (found == i) {
                            continue;
                        }
                        res.add(Arrays.asList(i, found));
                    }
                }
            }
        }
        return res;
    }
    
    private String reverse(String s) {
        StringBuilder sb = new StringBuilder(s);
        return sb.reverse().toString();
    }
    
    private boolean isPalindrome(String s) {
        int i = 0;
        int j = s.length() - 1;
        while (i < j) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
}
复制代码

相关题目:

46. Permutations [Medium]

  • 思路: Backtracking, 使用一个辅助的used数组来进行判断
class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return res;
        }
        int n = nums.length;
        boolean[] used = new boolean[n];
        helper(res, new ArrayList<>(), used, nums);
        return res;
    }
    
    private void helper(List<List<Integer>> res, List<Integer> curr, boolean[] used, int[] nums) {
        if (curr.size() == nums.length) {
            res.add(new ArrayList(curr));
        }
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                curr.add(nums[i]);
                used[i] = true;
                helper(res, curr, used, nums);
                used[i] = false;
                curr.remove(curr.size() - 1);
            }
        }
    }
}
复制代码

有重复元素

Arrays.sort(nums) // 排序这样所有重复的数
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1]) { continue; } // 跳过会造成重复的情况
复制代码

78. Subsets [Medium]

  • 思路: for 循环的起点不同，Permutation是必须利用每一个字符的，所以每次循环都从字符串的起点i = 0开始遍历，而Subset问题是不能回头的，所以不管之前的字符是否使用过，都只能从当前字符往后走，每次循环的起点是i = start, 同时递归function当中的起点也应该是i + 1。
class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
    	Arrays.sort(nums);
    	helper(results, new ArrayList<>(), nums, 0);
    	return results;       
    }
// 1.递归的定义: 在nums中找到所有的subset，每个元素都有两个选择, 加入和不加入
    private void helper(List<List<Integer>> results,
                        List<Integer> subset,
                        int[] nums,
                        int start) {
    //2. 递归的拆解 deep copy -> create new subset ArrayList
    //每一层都加当前的新元素
    //添加顺序: [] [1] [1,2] [1,2,3] [1,3] [2] [2,3] [3]
    
    results.add(new ArrayList(subset));
    for (int i = start; i < nums.length; i++) {
    	//[] -> [1] or [1] -> [1, 2]
    	subset.add(nums[i]);
    	helper(results, subset, nums, i + 1);
    	subset.remove(subset.size() - 1);
    }
    // 3. 递归的出口
    // 当for循环的条件不满足时,直接什么都不执行 => return 
    }
}
复制代码

转载于:https://juejin.im/post/5c51823ce51d4556940c282a

weixin_33875839
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
经典面试题：三种解法求解最长回文子字符串
mango_12345的博客
05-16 172
回文串是指正反两个方向都一样的字符串。故很容易想到暴力解法，列出所有的回文子串，再判断res是否等于res[：：-1] 此种解法的时间复杂度是O（n3） ####最长回文子串 def longestPalindrome(s): n=len(s) max_len=1 ##给定初始最大长度 res=s[0] ##设初值 if n<=1:return res ##当只有单个字符时，一定是回文串 for j in range
面试题之回文字符串
weixin_33801856的博客
10-30 299
2019独角兽企业重金招聘Python工程师标准>>> ...
面试题之最长回文字串
斯巴达的勇士已经是雅典的臣民了。。。
10-13 2956
这个问题也是一个很有名的问题了，在pongba的群里面问起过，还有人引出了suffix tree来解决这样的问题，这个就是最长回文字的问题How will you find the longest palindrome in a string? I.e. if the string is XMADAMYX, Your code should print MADAM这个问题用后缀树解决
回文字符串
baidu_19950899的专栏
08-30 323
1. Valid Palindrome Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases. For example, "A man, a plan, a canal: Panama" is a palindrome. "ra
《剑指offer》面试题20：回文子字符串的个数
inside802的博客
09-05 163
""" 题目：给定一个字符串，请问该字符串中有多少个回文连续子字符串？例如，字符串'ABC'有3个回文子字符串，分别为'A','B','C'； 而字符串‘AAA'有6个回文子字符串，分别为’A','A','A','AA','AA','AAA' 解题思路：这个题上来一看，我的脑子里就把它翻译为求子字符串为回文的个数。 前面已经做了很多子数组或者子字符串的题了，那一定是要用到双指针了。核心逻辑就是如何移动双指针。 首先确定双指针的起始位置和方向： 如果按
分享两道有关回文数的常见面试题
机器学习算法那些事
03-02 399
回文数是正反读都是相同的数，如回文数 123321，正反读都是一样的，如回文字符串 “abccba”。面试官常常会考回文数的编程题，今天小编分享两道关于回文数的面试题。1. 求字符串中最大...
C++ string字符串类详解
qq_41961154的博客
02-04 215
string 是 C++ 中常用的一个类，它非常重要，我们有必要在此单独讲解一下。 #include <iostream> #include <string> using namespace std; int main(){ string s1; string s2 = "c plus plus"; string s3 = s2; stri...
LeetCode(9)-Python-回文数(palindrome-number)
Paul_wang的博客
09-30 588
题目描述 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。 示例 输入: 121 输出: true 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。 解题思路 判断一个整数是否是一个回文...
哈希（2）
u011747152的博客
10-24 211
原题：/** * Created by gouthamvidyapradhan on 10/03/2017. * Given an array of strings, group anagrams together. * <p> * For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"], * Return: * <p
字符流中的第一个不重复的字符（思路与实现）
疯狂的1024
07-01 2782
题目描述请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。思路：其实这道题的主要思路就是利用一个数组，然后数组的下标就是这个字符对应的整数。这么进来一个字符，先吧这个字符放入一个Stringbuffer。就将判断该字符对应下标在数组中的值...
java经典算法和例题
阿华田的博客
01-21 4406
1.找出数组中只出现一次的数，其他元素出现两次。 方法一 package example; /* *@author 王志华 *@E-mail: 2602565232@qq.com *@date 创建时间：2018年1月26日 下午2:42:37 **/ public class FindOne { public static void main(String[] ar
［面试题］回文字符串
weixin_42645168的博客
11-13 457
预备知识： １java.lang.String.charAt()方法 返回 指定索引 处的 char值。索引范围 是从0 到length() - 1。 源码： public char charAt(int index) { if ((index < 0) || (index >= value.length)) { throw new St...
字符串面试题（五）验证一个字符串是否是回文串
IT界奋斗者的博客
12-10 754
所谓的字符串儿回文，就是无论是正序读还是反序读，它都是一毛一样的，比如说字符串儿“eye”，无论是从左往右读，还是从右往左读，它都是同一个字符串儿。请编写函数，它的功能是检查字符串s是否是回文，即正向，反向的拼写都一样。如noon，eye，level等，当字符串s是回文时，函数的返回值是true，否则返回值是false. bool Palindrome(String str){ int i,j...
Leetcode exercise record --- STRING 9 exercises
yana的博客
08-03 354
????Leetcode exercise record???? STRING 9 exercises ****刷题小结**** 1.万事开头难，坚持刷题进度，加油，会越来越好 2.双端队列 3.逆序调用 4.动态数组，vector 6.循环 -数组处理：翻倍数组 7.求余，push前赋值 8.其他单调栈问题待练习，496，901，42，84 文章目录????Leetcode exercise record???? STRING 9 exercises151. 翻转字符串里的单词 ❓???? MEDIUM
面试题：如何判断一个字符串是否是回文字符串
天元白手的博客
09-20 4434
回文字符串：aba、abcba 不是回文字符串：abcde、aabbcc、abcde 思路：首先我们要了解回文字符串的特性，比如abcba，我假设这些元素都有各自的下标： 我们可以发现，回文数字下标为1对应的元素等于下标为5对应的元素，下标为2的元素等于下标为4的元素。那么我们就可以根据这个特性编写代码： /** * 回文字符串 * @author Think */ public class Test_1 { public static void main(String[] args) {
java面试题：制造回文字符串
潇潇子卿的博客
07-26 1027
题目：牛牛有一些字母卡片,每张卡片上都有一个小写字母,所有卡片组成一个字符串s。牛牛一直认为回文这种性质十分优雅,于是牛牛希望用这些卡片拼凑出一些回文串,但是有以下要求: 1、每张卡片只能使用一次 2、要求构成的回文串的数量最少 牛牛想知道用这些字母卡片,最少能拼凑出多少个回文串。 例如: s = "abbaa",输出1,因为最少可以拼凑出"ababa"这一个回文串 s = "abc",
Palindrome Partitioning
涛涛不解
04-13 592
题目大意：给定一个字符串，要求你对其进行切割，保证切割后每个子字符串都是回文串，要你求所有满足条件的集合 解题思路：递归，为了避免重复计算，用isPalindrome[i][j]表示str[i][j]是否是回文串，为0表示不是，1表示是，-1表示还没有遍历进行判断 class Solution { public: vector> partition(string s) {
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 556
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
1. LeetCode-数组和字符串
最新发布
weixin_43149506的博客
07-18 747
数组和字符串介绍以及相关例题
Golang | Leetcode Golang题解之第233题数字1的个数
weixin_66442839的博客
07-14 245
Golang | Leetcode Golang题解之第233题数字1的个数

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值