字符串算法练习

0. 用到的基础功能库 tools.h

代码如下：

点击查看代码

#include<vector>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;

struct ListNode
{
   int val;
    ListNode* next;
    ListNode(int val) : val(val), next(nullptr) {}
};

template<typename T>
void showArr(const vector<T>& nums)
{
    cout << '[';
    for (int i = 0; i < nums.size(); ++i)
    {
        cout << nums[i];
        if (i != nums.size() - 1)
            cout << ',';
    }
    cout << ']' << endl;
}

void showList(ListNode* head)
{   
    ListNode* cur = head;
    cout << "[";
    while (cur)
    {
        cout << cur->val << ", ";
        cur = cur->next;
    }
    cout << "]" << endl;
}

template<typename T>
void showArr2D(const vector<vector<T>>& nums)
{
    cout << '[';
    for (int i = 0; i < nums.size(); ++i)
    {
        cout << '[';
        for (int j = 0; j < nums[i].size(); ++j)
        {
            cout << nums[i][j];
            if (j != nums[i].size() - 1)
                cout << ',';
        }
        cout << ']';
        if (i != nums.size() - 1)
                cout << ',';
    }
    cout << ']' << endl;
}

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"]

代码如下：

点击查看代码

#include"../tools.h"

void ReverseStr(vector<char>& s)
{
    if (s.size() < 2) return;
    int left = 0, right = s.size() - 1;
    while (left < right)
        swap(s[left++], s[right--]);
    return;
}

int main()
{
    vector<char> s = {'h','e','l','l','o'};
    ReverseStr(s);
    showArr<char>(s);
    return 0;
}

2. 反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起,
每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例:
输入: s = "abcdefg", k = 2
输出: "bacdfeg"

代码如下：

点击查看代码

#include"../tools.h"

void reverse(string& s, const int start, const int end)
{
    int left = start, right = end;
    while (left < right)
        swap(s[left++], s[right--]);
}

void ReverseStrPos(string& s, const int k)
{
    for (int i = 0; i < s.size(); i += (2*k))
    {
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
        if (s.size() >= i + k)
        {
            reverse(s, i, i + k - 1);
            continue;
        }
        // 3. 剩余字符少于 k 个，则将剩余字符全部反转
        reverse(s, i, s.size() - 1);
    }
}

int main()
{
    string s;
    int k;
    cin >> s >> k;
    ReverseStrPos(s, k);
    cout << s << endl;
    return 0;
}

3. 替换数字

给定一个字符串 s，它包含小写字母和数字字符，
请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。
例如，对于输入字符串 "a1b2c3"，函数应该将其转换为 "anumberbnumbercnumber"。
对于输入字符串 "a5b"，函数应该将其转换为 "anumberb"

输入：
一个字符串 s,s 仅包含小写字母和数字字符。
输出：
打印一个新的字符串，其中每个数字字符都被替换为了 number

样例输入：
a1b2c3
样例输出：
anumberbnumbercnumber

数据范围：1 <= s.length < 10000。

代码如下：

点击查看代码

#include"../tools.h"

bool IsNumber(const char& c)
{
    if (c >= '0' && c <= '9')
        return true;
    return false;
}

void ReplaceNum(string& s)
{
    int count = 0;
    int left = s.size() - 1;
    for (const auto& c : s)
    {
        if (IsNumber(c))
            ++count;
    }
    // 重新规划存储容量
    s.resize(s.size() + count * 5);
    int right = s.size() - 1;
    while (left >= 0)
    {
        // 倒叙插入
        if (IsNumber(s[left]))
        {
            s[right--] = 'r';
            s[right--] = 'e';
            s[right--] = 'b';
            s[right--] = 'm';
            s[right--] = 'u';
            s[right--] = 'n';
        }
        else 
        {
            s[right--] = s[left];
        }
        --left;
    }
}

int main()
{
    string s;
    cin >> s;
    ReplaceNum(s);
    cout << s << endl;
    return 0;
}

4. 翻转字符串里的单词

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

示例 1：
输入: "the sky is blue"
输出: "blue is sky the"

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

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

代码如下：

点击查看代码

#include "../tools.h"
void RemoveExtraSpace(string& s)
{
    int left = 0;
    for (int i = 0; i < s.size(); ++i)
    {
        if (s[i] != ' ')
        {
            // 填单词前，先补空格
            if (left != 0) s[left++] = ' ';
            // 一口气填完
            while (i < s.size() && s[i] != ' ')
            {
                s[left++] = s[i++];
            }
        }
    }
    s.resize(left);
}

void Reverse(string& s, int start, int end)
{
    int i = start, j = end;
    while (i < j)
        swap(s[i++], s[j--]);
}

void ReverseWord(string& s)
{
    RemoveExtraSpace(s);
    Reverse(s, 0, s.size() - 1);

    int idx = 0;
    for (int i = 0; i <= s.size(); ++i)
    {
        // 空格或串尾
        if (s[i] == ' ' || i == s.size())
        {
            Reverse(s, idx, i - 1);
            idx = i + 1;
        }
    }
}

int main()
{
    string s = " an good   example!     ";
    ReverseWord(s);
    cout << s << endl;
    return 0;
}

5. 右旋字符串

字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。
给定一个字符串 s 和一个正整数 k，请编写一个函数，
将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。

输入：
输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。
输出：
输出共一行，为进行了右旋转操作后的字符串。

示例
输入：
2
abcdefg
输出：
fgabcde

代码如下：

点击查看代码

#include"../tools.h"

void Reverse(string& s, int i, int j)
{
    int start = i, end = j;
    while (start < end)
        swap(s[start++], s[end--]);
}

void RightRotation(string& s, const int k)
{
    Reverse(s, 0, s.size() - 1);
    Reverse(s, 0, k - 1);
    Reverse(s, k, s.size() - 1);
}

int main()
{
    int n;
    string s;
    cin >> n >> s;
    RightRotation(s, n);
    cout << s << endl;
    return 0;
}

6. 实现 strStr()

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

示例 1: 
输入: haystack = "hello", needle = "ll" 
输出: 2

示例 2: 
输入: haystack = "aaaaa", needle = "bba" 
输出: -1

说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

代码如下：

点击查看代码

#include "../tools.h"

void GetNext(vector<int>& next, const string& s)
{
    // 初始化
    int j = 0;
    next[0] = j;
    for (int i = 1; i < s.size(); ++i)
    {   
        // 不匹配
        while (j > 0 && s[i] != s[j])
        {
            j = next[j - 1];
        }
        // 匹配
        if (s[i] == s[j])
            ++j;
        // 更新
        next[i] = j;
    }
}

int strStr(const string haystack, const string needle)
{
    if (needle.size() == 0) 
        return 0;
    vector<int> next(needle.size());
    // next 数组
    GetNext(next, needle);
    int j = 0;
    for (int i = 0; i < haystack.size(); ++i)
    {
        // 当前面匹配过，但后续不等，查找 next 数组
        while (j > 0 && haystack[i] != needle[j])
            j = next[j - 1];
        // 相等就下一个
        if (haystack[i] == needle[j])
            ++j;
        // 全部匹配完就结束，返回位置索引
        if (needle.size() == j)
            return i - needle.size() + 1;
        // 不等就继续，直到有匹配
    }
    return - 1;
}

int main()
{
    string haystack = "hello", needle = "ll";
    cout << strStr(haystack, needle) << endl;
    return 0;
}

7. 重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1:
输入: "abab"
输出: True
解释: 可由子字符串 "ab" 重复两次构成。

示例 2:
输入: "aba"
输出: False

示例 3:
输入: "abcabcabcabc"
输出: True
解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)

代码如下：

点击查看代码

#include"../tools.h"
void GetNext(vector<int>& next, const string s)
{
    int j = 0;
    for (int i = 1; i < s.size(); ++i)
    {
        while (j > 0 && s[i] != s[j])
            j = next[j - 1];
        if (s[i] == s[j])
            ++j;
        next[i] = j;
    }
}

bool IsReplicatedStr(const string s)
{
    if (s.size() == 0) return false;
    vector<int> next(s.size());
    GetNext(next, s);
    // 存在公共前后缀且满足差的整除
    int len = s.size();
    if (next[len - 1] != 0 && len % (len - next[len - 1]) == 0)
        return true;
    return false;
}

int main()
{
    string s = "abcabcabcabc";
    cout << IsReplicatedStr(s) << endl;
    return 0;
}