关于字符串的几道算法面试题

最新推荐文章于 2024-04-28 01:45:00 发布
最新推荐文章于 2024-04-28 01:45:00 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Leetcode精选面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iov3Rain/article/details/88316346
版权

一

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:

输入: "A man, a plan, a canal: Panama" 输出: true

示例 2:

输入: "race a car" 输出: false

注意：'0' + 'a' - 'A' = 'P'

class Solution
{
  public:
    bool isPalindrome(string s)
    {
        int len = s.size();
        if(len <= 1)
        {
            return true;
        }
        int low = 0, high = len - 1;
        while(low < high)
        {
            if(s[low] >= 'a' && s[low] <= 'z' || s[low] >= 'A' && s[low] <= 'Z' || s[low] >= '0' && s[low] <= '9')
            {
                if (s[high] >= 'a' && s[high] <= 'z' || s[high] >= 'A' && s[high] <= 'Z' || s[high] >= '0' && s[high] <= '9')
                {
                    if((s[low] >= '0' && s[low] <= '9' && (s[high] < '0' || s[high] > '9')) || (s[high] >= '0' && s[high] <= '9' && (s[low] < '0' || s[low] > '9')))
                    {
                        return false;
                    }
                    else if (s[low] != s[high] && s[low] + 'a' - 'A' != s[high] && s[low] - 'a' + 'A' != s[high])
                    {
                        return false;
                    }
                    else
                    {
                        low++;
                        high--;
                    }
                }
                else
                {
                    high--;
                }
                
            }
            else
            {
                low++;
            }
        }
        return true;
    }
};

二

分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: "aab" 输出: [ ["aa","b"], ["a","a","b"] ]

 

DFS搜索

class Solution
{
    vector<vector<string>> ans;

  public:
    vector<vector<string>> partition(string s)
    {
        vector<string> arr;
        GetAns(s, 0, arr);
        return ans;
    }

    void GetAns(string s, int pos, vector<string> &arr)
    {
        if(pos >= s.size())
        {
            ans.push_back(arr);
            return;
        }
        for (int i = pos; i < s.size(); i++)
        {
            string temp(s.begin() + pos, s.begin() + i + 1);
            if(Check(temp))
            {
                arr.push_back(temp);
                GetAns(s, i + 1, arr);
                arr.pop_back();
            }
        }
    }

    bool Check(string s)
    {
        if(s.size() <= 1)
            return true;
        for (int i = 0, j = s.size() - 1; i < j; i++, j--)
        {
            if(s[i] != s[j])
                return false;
        }
        return true;
    }
};

三

单词拆分

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

  • 拆分时可以重复使用字典中的单词。
  • 你可以假设字典中没有重复的单词。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"] 输出: true 解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"] 输出: true 解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。   注意你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"] 输出: false

DP

dp：
class Solution
{
  public:
    bool wordBreak(string s, vector<string> &wordDict)
    {
        if(wordDict.size() <= 0)
        {
            return false;
        }
        if(s.size() <= 0)
        {
            return true;
        }
        map<string, bool> Check;
        for (int i = 0; i < wordDict.size(); i++)
        {
            Check[wordDict[i]] = true;
        }
        vector<bool> dp(s.size(), false);
        for (int i = 0; i < s.size(); i++)
        {
            string temp(s.begin(), s.begin() + i + 1);
            if(Check[temp])
            {
                dp[i] = true;
                continue;
            }
            for (int j = 0; j < i; j++)
            {
                if(dp[j] == true)
                {
                    string temp2(s.begin() + j + 1, s.begin() + i + 1);
                    if(Check[temp2])
                    {
                        dp[i] = true;
                        break;
                    }
                }
            }
        }
        return dp[s.size() - 1];
    }
};

四

单词拆分II

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。

说明：

  • 分隔时可以重复使用字典中的单词。
  • 你可以假设字典中没有重复的单词。

示例 1：

输入: s = "catsanddog" wordDict = ["cat", "cats", "and", "sand", "dog"] 输出: [   "cats and dog",   "cat sand dog" ]

示例 2：

输入: s = "pineapplepenapple" wordDict = ["apple", "pen", "applepen", "pine", "pineapple"] 输出: [   "pine apple pen apple",   "pineapple pen apple",   "pine applepen apple" ] 解释: 注意你可以重复使用字典中的单词。

示例 3：

输入: s = "catsandog" wordDict = ["cats", "dog", "sand", "and", "cat"] 输出: []

 

DP加DFS

class Solution
{
    map<int, vector<string>> save;
    vector<string> ans;

  public:
    vector<string> wordBreak(string s, vector<string> &wordDict)
    {
        if (wordDict.size() <= 0)
        {
            return ans;
        }
        if (s.size() <= 0)
        {
            return ans;
        }
        map<string, bool> Check;
        for (int i = 0; i < wordDict.size(); i++)
        {
            Check[wordDict[i]] = true;
        }
        vector<bool> dp(s.size(), false);
        for (int i = 0; i < s.size(); i++)
        {
            string temp(s.begin(), s.begin() + i + 1);
            if (Check[temp])
            {
                dp[i] = true;
                save[i].push_back(temp);
            }
            for (int j = 0; j < i; j++)
            {
                if (dp[j] == true)
                {
                    string temp2(s.begin() + j + 1, s.begin() + i + 1);
                    if (Check[temp2])
                    {
                        dp[i] = true;
                        save[i].push_back(temp2);
                    }
                }
            }
        }
        if(!dp[s.size() - 1])
            return ans;
        DFS(s.size(), "");
        return ans;
    }

    void DFS(int len, string s)
    {
        if(len == 0)
        {
            ans.push_back(s);
            return;
        }
        for (int i = 0; i < save[len - 1].size(); i++)
        {
            DFS(len - save[len - 1][i].size(), save[len - 1][i]+ (s == ""? "" : " ") + s);
        }
    }
};

五

实现Trie字典树

实现一个 Trie (前缀树)，包含 insert, search, 和 startsWith 这三个操作。

示例:

Trie trie = new Trie(); trie.insert("apple"); trie.search("apple"); // 返回 true trie.search("app"); // 返回 false trie.startsWith("app"); // 返回 true trie.insert("app"); trie.search("app"); // 返回 true

说明:

  • 你可以假设所有的输入都是由小写字母 a-z 构成的。
  • 保证所有输入均为非空字符串。

class Trie
{
    struct TrieNode
    {
        bool isWord;
        vector<TrieNode *> children;
        TrieNode()
        {
            isWord = false;
            children = vector<TrieNode *>(26, NULL);
        }
        ~TrieNode()
        {
            for (int i = 0; i < 26; i++)
            {
                if (children[i] != NULL)
                {
                    delete children[i];
                }
            }
        }
    };

    private:
      TrieNode *root;

    public:
      Trie()
      {
          root = new TrieNode();
      }
      ~Trie()
      {
          delete root;
      }

      bool find(string word, TrieNode *&newRoot)
      {
          for (int i = 0; i < word.size(); i++)
          {
              if (newRoot->children[word[i] - 'a'] == NULL)
              {
                  return false;
              }
              newRoot = newRoot->children[word[i] - 'a'];
          }
          return true;
    }

    void insert(string word)
    {
        TrieNode* newRoot = root;
        for (int i = 0; i < word.size(); i++)
        {
            if (newRoot->children[word[i] - 'a'] == NULL)
            {
                newRoot->children[word[i] - 'a'] = new TrieNode();
            }
            newRoot = newRoot->children[word[i] - 'a'];
        }
        newRoot->isWord = true;
    }


    bool search(string word)
    {
        TrieNode *newRoot = root;
        return (find(word, newRoot) && newRoot->isWord);
    }

    bool startsWith(string prefix)
    {
        TrieNode *newRoot = root;
        return find(prefix, newRoot);
    }
};

六

有效的字母异位词

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

示例 1:

输入: s = "anagram", t = "nagaram" 输出: true

示例 2:

输入: s = "rat", t = "car" 输出: false

说明:

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

class Solution
{
  public:
    bool isAnagram(string s, string t)
    {
        map<char, int> str1;
        map<char, int> str2;
        if(s.size() != t.size())
            return false;
        for(char c : s)
        {
            str1[c]++;
        }
        for(char c : t)
        {
            str2[c]++;
        }
        for(char c : s)
        {
            if(str1[c] != str2[c])
                return false;
        }
        return true;
    }
};

七

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

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

案例:

s = "leetcode" 返回 0. s = "loveleetcode", 返回 2.

 

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

class Solution
{
  public:
    int firstUniqChar(string s)
    {
        map<char, int> save;
        for(char c : s)
        {
            save[c]++;
        }
        for (int i = 0; i < s.size(); i++)
        {
            if(save[s[i]] == 1)
                return i;
        }
        return -1;
    }
};

 

八

反转字符串

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

class Solution
{
  public:
    void reverseString(vector<char> &s)
    {
        int i = 0, j = s.size() - 1;
        for (; i < j; i++, j--)
        {
            swap(s[i], s[j]);
        }
    }
};

九

单词搜索II

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。

示例:

输入: words = ["oath","pea","eat","rain"] and board = [ ['o','a','a','n'], ['e','t','a','e'], ['i','h','k','r'], ['i','f','l','v'] ] 输出: ["eat","oath"]

说明:

你可以假设所有输入都由小写字母 a-z 组成。

提示:

  • 你需要优化回溯算法以通过更大数据量的测试。你能否早点停止回溯？
  • 如果当前单词不存在于所有单词的前缀中，则可以立即停止回溯。什么样的数据结构可以有效地执行这样的操作？散列表是否可行？为什么？ 前缀树如何？如果你想学习如何实现一个基本的前缀树，请先查看这个问题： 实现Trie（前缀树）。

 

前缀数加DFS

class Solution
{
  public:
    struct TrieNode
    {
        vector<TrieNode *> children;
        bool isWord;
        TrieNode()
        {
            children = vector<TrieNode *>(26, NULL);
            isWord = false;
        }
        ~TrieNode()
        {
            for (int i = 0; i < 26; i++)
            {
                if (children[i] != NULL)
                {
                    delete children[i];
                }
            }
        }
    };

    class Trie
    {
      public:
        TrieNode *root;
        Trie()
        {
            root = new TrieNode();
        }
        ~Trie()
        {
            delete root;
        }
        void insert(string word)
        {
            TrieNode *newRoot = root;
            for (int i = 0; i < word.size(); i++)
            {
                if (newRoot->children[word[i] - 'a'] == NULL)
                {
                    newRoot->children[word[i] - 'a'] = new TrieNode();
                }
                newRoot = newRoot->children[word[i] - 'a'];
            }
            newRoot->isWord = true;
        }
    };
    void DFS(vector<vector<char>> &board, vector<vector<bool>> &visit, TrieNode *newRoot, int row, int col, string str)
    {
        if (newRoot == NULL)
            return;
        if (newRoot->isWord)
        {
//标记为false，防止出现重复的答案
            newRoot->isWord = false;
            ans.push_back(str);
            //注意如果这里return的话，某些案例下会少答案，原因可想而知
        }
        for (int i = 0; i < 4; i++)
        {
            int newRow = row + dx[i];
            int newCol = col + dy[i];
            if (newRow < 0 || newRow >= borderRow || newCol < 0 || newCol >= borderCol)
                continue;
            if (visit[newRow][newCol])
                continue;
            if (newRoot->children[board[newRow][newCol] - 'a'] == NULL)
                continue;
            visit[newRow][newCol] = true;
            DFS(board, visit, newRoot->children[board[newRow][newCol] - 'a'], newRow, newCol, str + board[newRow][newCol]);
            visit[newRow][newCol] = false;
        }
    }
    vector<string> findWords(vector<vector<char>> &board, vector<string> &words)
    {
        t = new Trie();
        borderRow = board.size();
        if (borderRow == 0 || words.size() == 0)
        {
            return ans;
        }
        borderCol = board[0].size();
        vector<vector<bool>> visit(borderRow, vector<bool>(borderCol, false));
        map<string, bool> check;
        string str = "";
        for(string s : words)
        {
            t->insert(s);
        }
        for (int r = 0; r < borderRow; r++)
        {
            for (int c = 0; c < borderCol; c++)
            {
                if (t ->root ->children[board[r][c] - 'a'] != NULL)
                {
                    visit[r][c] = true;
                    TrieNode *newRoot = t->root->children[board[r][c] - 'a'];
                    DFS(board, visit, newRoot, r, c, str + board[r][c]);
                    visit[r][c] = false;
                }
            }
        }
        return ans;
    }
    private:
      Trie *t;
      int dx[4] = {1, -1, 0, 0};
      int dy[4] = {0, 0, 1, -1};
      int borderRow;
      int borderCol;
      vector<string> ans;
};

 

lMonster81
关注
专栏目录
22道数据结构算法面试题.zip_22道数据结构算法面试题_算法面试题
09-20
这份"22道数据结构算法面试题.zip"压缩包文件显然旨在帮助求职者准备这些关键的面试环节。以下是对这些可能面试题目的详细解读，以及相关的知识点。 1. **链表操作**：链表是一种线性数据结构，它通过节点间的指针...
面试经典150题——无重复字符的最长子串
m0_60388871的博客
02-13 975
首先自然的暴力解法，就是遍历字符串的每一个字符，从当前位置开始前向后尝试，找到最长的不含有重复字符的长度，最后得到的所有起始点长度中最大的就是题目的解。需要遍历每个下标作为子串的开始下标，对于每个开始下标，需要遍历其后面的下标得到长度最大的不包含重复字符的字符串。根据滑动窗口的思想，我们首先定义两个指针，表示窗口的头和尾部。从头开始遍历字符串的第一个字符，尾部指针从第二个字符开始，只要发现当前字符。当发现字符相同，记录不相同字符串长度，从头部不断移除字符，直到串口内部的字符串又不相同。
关于字符串操作的面试题（牛客网视频文字个人理解版）
corbiekiki的博客
04-06 1689
1.规则判断类型 判断字符串是否符合整数规则/浮点数规则/回文字符串规则。 2.数字运算（大整数相关的加减乘除操作） 3.与数组操作有关的类型（与数组有关的调整、排序等操作） 4.字符计数（@1.使用哈希表@2.使用固定长度的 数组@3.用于解决滑动窗口问题、寻找无重复字符子串的问题、计算变位词问题等） 5.动态规划类型 6.搜索类型（@1.宽度有限搜索） 7.高级算法与数据结构
面试算法题 专题（一） —— 字符串
JohnnyLin
07-03 502
面试题 01.09. 字符串轮转 【题目描述】 面试题 01.09. 字符串轮转 解法一 【思路】 指向s1的指针从前往后遍历逐一与s2的头一个字符比较 ，相等位置即为可能的旋转位置。旋转词极可能为： c[i + 1: n -1] + c[0：i] class Solution { public boolean isFlipedString(String s1, String s2) { if( s1 == null || s2 == null) return false;
字符串相关高频面试题算法
2301_77822280的博客
06-13 1093
最后一题综合前几个题用到的一些技巧，还是比较有趣的，这里就不贴出代码了，也激发一下大家的动手能力，感兴趣的童鞋不妨试着写一写。1、先将整个字符串翻转：如：I am a student =》 tneduts a ma I。1、交换：把一个只包含01的串排序，可交换任意两个数的位置，最少需要多少次交换？2、字符串替换和复制：删除一个字符串所有的a，并且复制所有的b（字符数组足够大）如：1 * 2 * 4 * 3 => * * * 1 2 4 3。5、子串变位词：给定两个串a和b，问b是否a的子串变位词。
Leetcode exercise record --- STRING 9 exercises
yana的博客
08-03 641
????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
字符串经典基础面试题
m0_53401014的博客
12-03 1242
关卡名字符串经典基础面试题我会了✔️内容1.理解字符串反转的处理方法2.熟练掌握回文串的判断方法3.掌握字符串中搜索第一个唯一字符的方法4.掌握判断是否互为字符串重排的处理技巧。
数据结构和算法面试题系列—字符串
Quasimodo24的博客
04-16 425
字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。
算法笔试题：（Python实现）—— 算法面试题汇总
01-21
算法笔试题：（Python实现）—— 算法面试题汇总算法笔试题：（Python实现）—— 算法面试题汇总开始之前Python实现只出现一次的数字多数元素搜索二维矩阵 II合并两个有序数组鸡蛋掉落字符串Python实现验证回文串...
程序员面试题精选-输出一个字符串的所有子串
03-12
对于面试而言，理解和掌握这两种方法有助于展示候选人在字符串处理和算法设计上的能力。同时，这也体现了在面对复杂问题时，如何通过变换思维角度，将问题简化为更易于处理的形式，这是编程解决问题的重要技巧之一。...
c语言面试题之哈希表字符串中的第一个唯一字符.zip
03-29
综上所述，解决“C语言面试题之哈希表字符串中的第一个唯一字符”不仅要求掌握C语言的基础语法，还需理解哈希表的原理和应用，以及具备良好的算法设计和分析能力。熟练掌握这些知识点，对于提升C语言编程技能和应对...
关于数据结构与算法80道题
03-16
10. **字符串处理**：KMP算法、Rabin-Karp算法、Boyer-Moore算法等用于字符串匹配；Manacher's Algorithm处理回文子串问题。 11. **位运算**：位运算在优化代码和解决特定问题时非常有用，如奇偶校验、颜色翻转、...
字符串类型的算法面试
zcf396720的专栏
11-20 767
字符串类型的算法面试题特点 1. 广泛性 1.字符串可以看做字符类型的数组与数组排序、查找、调整有关 2.很多其它类型的面试题可以看做字符串类型的面试题 注意：用JAVA实现字符串类型的题目是，由于java.lang.String类型不可修改，我们可以使用StringBuffer，StringBuileder类和toCharArray方法。 2. 需掌握的概念
面试算法题精讲：最长回文子串
ProgramNovice的博客
04-28 982
面试算法题精讲：最长回文子串
C语言面试题（字符和字符串处理）
D卡戎的博客
03-12 862
C语言面试必备，字符串处理相关面试题
算法通关村十二关——字符串经典基础面试题
m0_73071896的博客
12-09 352
【代码】算法通关村十二关——字符串经典基础面试题。
面试 | 校招字符串相关高频算法题汇总【C++实现】
做技术人 · 产优质博客 · 找好工作
07-29 810
收集在校招面试当中符串相关高频算法题，持续更新中。。。
leetcode 探索算法面试题汇总——字符串
Sunshine8430的博客
03-17 1055
总结字符串相关的题目，积累： 一、验证回文串 1.1 题目描述 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例 1: 输入: “A man, a plan, a canal: Panama” 输出: true 示例 2: 输入: “race a car” 输出: false 1.2 解题思路 对于只包含小写字...
【超强组合】基于淘金优化算法GRO-BP-Adaboost的数据分类预测算法Matlab实现.rar
最新发布
10-08
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
微软22道数据结构算法面试题解析
"微软的22道数据结构算法面试题包含反转链表、二叉树的广度优先遍历以及字符串排列等经典问题，旨在考察面试者的算法基础和逻辑思维能力。" 在这22道算法面试题中，我们可以看到一些核心的编程概念和常见问题的解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值