leetcode 字符串题目集锦

反转字符串leetcode 344

题目：

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

示例 1:

输入: "hello"
输出: "olleh"

示例 2:

输入: "A man, a plan, a canal: Panama"
输出: "amanaP :lanac a ,nalp a ,nam A"

这里直接用STL的反向迭代器就可以搞定了，代码：

class Solution {
public:
    string reverseString(string s) {
        string res(s.rbegin(),s.rend());//这里s.crbegin()和s.crend()也可以
        return res;
        
    }
};

字符串中的单词数 leetcode434

题目:

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: "Hello, my name is John"
输出: 5

解法一

我们最简单做法是遍历字符串，遇到空格直接跳过，如果不是空格，则计数器加1，然后用个while循环找到下一个空格的位置，这样就遍历完了一个单词，再重复上面的操作直至结束，就能得到正确结果：

class Solution {
public:
    int countSegments(string s) {
        int res = 0, n = s.size();
        for (int i = 0; i < n; ++i) {
            if (s[i] == ' ') continue;
            ++res;
            while (i < n && s[i] != ' ') ++i;
        }
        return res;
    }
};

解法二

我们还可以利用C++的字符串流操作，利用getline函数取出每两个空格符之间的字符串，由于多个空格符可能连在一起，所以有可能取出空字符串，我们要判断一下，如果取出的是非空字符串我们才累加计数器，参见代码如下：

class Solution {
public:
    int countSegments(string s) {
        int res = 0;
        istringstream is(s);
        string t = "";
        while (getline(is, t, ' ')) {
            if (t.empty()) continue;
            ++res;
        }
        return res;
    }
};

字符串相加 leetcode 415

题目：

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

注意：
    num1 和num2 的长度都小于 5100.
    num1 和num2 都只包含数字 0-9.
    num1 和num2 都不包含任何前导零。
    你不能使用任何內建 BigInteger 库， 
    也不能直接将输入的字符串转换为整数形式。

思路解析：

这题其实只用模拟一下小学的竖式加法就好了，更多的技巧是在如何让代码写的更优雅。

我们以1254和147相加为例来看看竖式加法:

  1 2 5 4
+   1 4 7
---------
  1 4^0^1

Out: 1401
Note: ^ 符号代表低位产生进位

下面来说说竖式加法的几个要注意的地方：

低位对齐，即以字符串尾对齐；
加法仅为0-9与0-9间的数字相加，除此之外还要带上低位的进位；
低位的进位只可能是0或1，且初始为0；
加法可能产生进位，但进位最多为1（0-9与0-9间的数字相加，再加上进位，最大为19）。

那么算法就呼之欲出了：

想要低位对齐，就同步从两个字符串的最后一个字符向前遍历，直到两个字符串均遍历完成。
若中途有一个字符串遍历完成，则此后将此字符串的字符认作0。
定义变量carry记录低位的进位，初始值为0。
每次遍历时，将carry更新为加上两个字符值之后的值，再以carry的个位的数字作为当前位置的结果，更新carry为其十位上的数字（进位）。
遍历字符串完成后，如果carry为1（最高位有进位），则将1添加到结果。
输出结果。

代码如下：

class Solution {
public:
    string addStrings(string num1, string num2) {
        int i = num1.size() - 1;
        int j = num2.size() - 1;
        string result = "";
        int carry = 0;
        while (i >= 0 || j >= 0) {
            if (i >= 0) {
                carry += num1[i] - '0';
            }
            if (j >= 0) {
                carry += num2[j] - '0';
            }
            result += (char)(carry % 10 + '0');
            carry /= 10;
            i--;
            j--;
        }
        if (carry == 1) {
            result += '1';
        }
        reverse(result.rbegin(), result.rend());
        return result;
    }
};

当然你也可以精简下代码，如下：

class Solution {
public:
    string addStrings(string num1, string num2) {
        
        string res = "";
        int m = num1.size(), n = num2.size();
        int i = m - 1, j = n - 1, carry = 0;
        while (i >= 0 || j >= 0) {
            int a = i >= 0 ? num1[i--] - '0' : 0;
            int b = j >= 0 ? num2[j--] - '0' : 0;
            int sum = a + b + carry;
            res.insert(res.begin(), sum % 10 + '0');
            carry = sum / 10;
        }
        return carry ? "1" + res : res;
        
    }
};

反转字符串中的元音字母 leetcode 345

题目：

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1:

输入: "hello"
输出: "holle"

示例 2:

输入: "leetcode"
输出: "leotcede"

说明:
元音字母只有"a,e,i,o,u",不包含字母"y"。

思路一

这道题让我们翻转字符串中的元音字母，元音字母有五个a,e,i,o,u，需要注意的是大写的也算，所以总共有十个字母。我们写一个isVowel的函数来判断当前字符是否为元音字母，如果两边都是元音字母，那么我们交换，如果左边的不是，向右移动一位，如果右边的不是，则向左移动一位，参见代码如下：

class Solution {
public:
    string reverseVowels(string s) {
        int left = 0, right= s.size() - 1;
        while (left < right) {
            if (isVowel(s[left]) && isVowel(s[right])) {
                swap(s[left++], s[right--]);
            } else if (isVowel(s[left])) {
                --right;
            } else {
                ++left;
            }
        }
        return s;
    }
    bool isVowel(char c) {
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
    }
};

思路二

我们也可以用自带函数find_first_of和find_last_of来找出包含给定字符串中任意一个字符的下一个位置进行交换即可：

class Solution {
public:
    string reverseVowels(string s) {
        int left = 0, right = s.size() - 1;
        while (left < right) {
            left = s.find_first_of("aeiouAEIOU", left);
            right = s.find_last_of("aeiouAEIOU", right);
            if (left < right) {
                swap(s[left++], s[right--]);
            }
        }
        return s;
    }
};

最长公共前缀 leetcode14
题目：

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

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

示例 1:

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

示例 2:

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

说明:

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

思路解析：

1.strs为空（无字符串），则返回空串；

2.若不是上面情况，则依次比对第1个字符串和其他所有字符串的第1个字符、
第2个字符、第3个字符...第i个字符...直到某个字符串长度小于i+1，或者第i个字符不匹配，
则返回第1个字符串的前i个字符前缀为最长公共前缀；

3.若第一个字符串的所有字符均比对完毕，还未返回，则返回第1个字符串为最长公共前缀。

代码如下：

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        string prefix="";
        int len = strs.size();
        if(len==0)  return prefix;
        /** check char by char, for each char, check all the string word **/
        for(int k=0; k<strs[0].size(); k++){
            int i=1;
            for(; i<len && strs[i].size()>k; i++){
                if(strs[i][k]!=strs[0][k])
                    return prefix;
            }
            if(i==len) prefix = strs[0].substr(0,k+1);
        }
        return prefix;
    }
};

无重复字符的最长子串 leetcode 03

题目

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

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 无重复字符的最长子串是 "abc"，其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 无重复字符的最长子串是 "b"，其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 无重复字符的最长子串是 "wke"，其长度为 3。
     请注意，答案必须是一个子串，"pwke" 是一个子序列 而不是子串。

分析：

那么如何判断新字符是否已经在子串中出现过呢？
我们可以使用Map<char, bool>，它的原理是：将每个字符作为一个节点存在一颗二叉树中，
尝试插入新字符的节点，如果出现冲突（树中已经有相同字符的节点），则表明新字符已经出现过。
每次判断的复杂度为log(m)，m为子串的最大长度。
在进行子串左端点右移的时候，要记得将被移出的字符从map种删掉。
还有一种更高效的查找方法：哈希表。在这道题使用哈希表有天然的优势：char的范围是已知的、
较小的——[0, 255]（unsigned char）。
那么就可以直接用一个bool[256]数组来存储每一种字符是否已出现。
在进行子串左端点右移的时候，要记得将被移出的字符重新标记为未访问。

以上两种方法在进行子串左端点右移的时候都要进行重置操作。
为了避免它，我们不存储bool(是否出现过)，而是存储int(上次出现的下标)。详见下面的代码部分。

代码：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        map<char, int> last_appear_index;
        int sub_string_start = 0, max_length = 0;
        map<char, int>::iterator it;
        for (int i = 0; i < s.length(); i++) {
            it = last_appear_index.find(s[i]);
            if (it != last_appear_index.end() && it->second >= sub_string_start) {
                sub_string_start = it->second+1;
            }
            last_appear_index[s[i]] = i;
            max_length = max(max_length, i-sub_string_start+1);
        }
        return max_length;
        
    }
};

注释版：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
    int ret = 0;		
	map<char, int> m;	//map键-值对，添加的元素如果没有的话就会初始化		
	int start = 1;			
	for (int i = 1; i <= s.length(); i++)		
    {			
        char c = s[i - 1];			
        if (m[c] >= start)	//如果遇到相同的元素则把start放到元素的后面
        { 				
            start = m[c] + 1;				
            m[c] = i;			
        }			
        else			
        //否则更新长度，长度是通过i（尾部）和start（头部）来决定			
        {				
            m[c] = i;				
            ret = max(ret, i - start + 1);//更新:大于目前存储的最大元素			
        } 		
    }		
	return ret;	
        
    }
};