题目：两个字符串是变位词
题目难度：简单
题目描述：
写出一个函数 anagram(s, t) 判断两个字符串是否可以通过改变字母的顺序变成一样的字符串。
解题思路：
C++：引入哈希的思维，这道题就迎刃而解了。
C++ Code：
class Solution {
public:
/**
* @param s: The first string
* @param b: The second string
* @return true or false
*/
bool anagram(string s, string t) {
// write your code here
int dic[58];
for (int i = 0; i < 58; i++)
dic[i] = 0;
for ( int i = 0; i < s.size(); i++ )
{
if (s[i] == ' ')
continue;
int index = s[i] - 'A';
dic[index]++;
}
for ( int i = 0; i < t.size(); i++ )
{
if (t[i] == ' ')
continue;
int index = t[i] - 'A';
dic[index]--;
}
for ( int i = 0; i < 58; i++ )
{
if (i==57 && dic[i]==0)
return true;
if (dic[i] == 0)
continue;
else
return false;
}
}
};
Python：利用Python的list()方法与sort()方法就可以成功地解决这道问题。
Python Code：
class Solution:
"""
@param s: The first string
@param b: The second string
@return true or false
"""
def anagram(self, s, t):
# write your code here
a = list(s)
b = list(t)
a.sort()
b.sort()
if a == b:
return True
else:
return False
题目：比较字符串
题目难度：简单
题目描述：
比较两个字符串A和B，确定A中是否包含B中所有的字符。字符串A和B中的字符都是大写字母。
解题思路：
C++：与第一道题几乎一样的哈希思路。
C++ Code：
class Solution {
public:
/**
* @param A: A string includes Upper Case letters
* @param B: A string includes Upper Case letter
* @return: if string A contains all of the characters in B return true
* else return false
*/
bool compareStrings(string A, string B) {
// write your code here
int dic[26];
int index;
for (int i = 0; i < 26; i++)
dic[i] = 0;
for (int i = 0; i < A.size(); i++) {
if (A[i] == ' ')
continue;
index = A[i] - 'A';
dic[index]++;
}
for (int i = 0; i < B.size(); i++) {
if (B[i] == ' ')
continue;
index = B[i] - 'A';
dic[index]--;
}
for (int i = 0; i < 26; i++) {
if (dic[i] < 0)
return false;
if (i == 25 && dic[i] >= 0)
return true;
}
}
};
Python：利用Python中的list()方法与index()方法，将B中的字符在A中逐个比对，每一次将A中对应的字符删除，循环这个过程。
Python Code：
class Solution:
"""
@param A : A string includes Upper Case letters
@param B : A string includes Upper Case letters
@return : if string A contains all of the characters in B return True else return False
"""
def compareStrings(self, A, B):
# write your code here
a = list(A)
b = list(B)
for n in b:
if n in a:
index = a.index(n)
del a[index]
continue
else:
return False
return True
题目：字符串查找
题目难度：简单
题目描述：
对于一个给定的 source 字符串和一个 target 字符串，你应该在 source 字符串中找出 target 字符串出现的第一个位置(从0开始)。如果不存在，则返回-1。
解题思路：
C++：通过一个简单的二层循环嵌套进行比对即可解决此题，需要注意的是处理NULL情况。
C++ Code：
class Solution {
public:
/**
* Returns a index to the first occurrence of target in source,
* or -1 if target is not part of source.
* @param source string to be scanned.
* @param target string containing the sequence of characters to match.
*/
int strStr(const char *source, const char *target) {
// write your code here
if (source == NULL || target == NULL)
return -1;
int index, i;
int ssize = strlen(source);
int tsize = strlen(target);
if (ssize < tsize)
return -1;
for (index = 0; index <= ssize - tsize; index++)
{
for (i = 0; i <= tsize - 1; i++)
{
if (source[i + index] != target[i])
break;
}
if (i == tsize)
return index;
}
return -1;
}
};
Python：和C++的思路是大致相同的，但是可以运用Python中的字符串截取方法，代码比C++更简短，同样需要注意处理null情况（Python中为None）。
Python Code：
class Solution:
def strStr(self, source, target):
# write your code here
index = 0
if source is None or target is None:
return -1
if len(source) < len(target):
return -1
if source == target:
return 0
while index <= len(source) - len(target):
if source[index: index + len(target)] == target:
return index
if index == len(source) - len(target) and source != target:
return -1
index += 1
题目：乱序字符串
题目难度：中等
题目描述：
给出一个字符串数组S，找到其中所有的乱序字符串(Anagram)。如果一个字符串是乱序字符串，那么他存在一个字母集合相同，但顺序不同的字符串也在S中。
解题思路：
C++：先将字符串数组中的字符串都进行排序，然后运用unordered_map的特性来解决问题，值得一提的是，如果在排序方法中运用O(n^2)的方法，是会判定超时的。
C++ Code：
class Solution {
public:
/**
* @param strs: A list of strings
* @return: A list of strings
*/
void sort(string &input) {
int count[26];
int index;
for (int i = 0; i < 26; i++) {
count[i] = 0;
}
for (int i = 0; i < input.length(); i++) {
index = input[i] - 'a';
count[index]++;
}
input = "";
for (int i = 0; i < 26; i++) {
for (int j = 0; j < count[i]; j++) {
input += (char)('a' + i);
}
}
}
vector<string> anagrams(vector<string> &strs) {
// write your code here
vector<string> result;
vector<string> mystrs = strs;
for (int i = 0; i < mystrs.size(); i++) {
sort (mystrs[i]);
}
unordered_map<string, int> dic;
for (int i = 0; i < mystrs.size(); i++) {
if (dic.find(mystrs[i]) == dic.end())
dic[mystrs[i]] = 1;
else
dic[mystrs[i]]++;
}
for (int i = 0; i < mystrs.size(); i++) {
if (dic[mystrs[i]] == 1)
continue;
else
result.push_back(strs[i]);
}
return result;
}
};
Python：在思路上和C++解法并没有太大区别，但是由于Python语言本身的一些特性，可以让代码量相较于C++版本的解法大幅减少，运用Python中的字典类型与sorted()方法可以很简洁地解出这道题。（注：运用sort()方法也可以，但是sort()方法本身会改变list的值，会让代码量略微增多）
Python Code：
class Solution:
# @param strs: A list of strings
# @return: A list of strings
def anagrams(self, strs):
# write your code here
dic = {}
result = []
for string in strs:
sortedstr = "".join(sorted(string));
dic[sortedstr] = [string] if sortedstr not in dic else dic[sortedstr] + [string]
for key in dic:
result += dic[key] if len(dic[key]) >= 2 else []
return result
题目：最长公共子串
题目难度：中等
题目描述：
给出两个字符串，找到最长公共子串，并返回其长度。
解题思路：
C++：这道题固然是可以用遍历的方法硬解出来的，但是那样的复杂度是非常不令人满意的，这里比较好的方法是运用动态规划的思想来解答，假设在求最长公共子串对的过程中，A中的子串中最后一个字符的位置为i，B中的子串中最后一个字符的位置为j，实际上就可以把“分别以A[i]与B[j]作为最后一个字符时最长公共字串的长度是多少”当作动态规划中的子问题，设分别以A[i]与B[j]作为最后一个字符时最长公共字串的长度为longestCommonSubstring[i][j]，不难得出longerstCommonSubstring[i][j] = (A[i] == B[j] ? longestCommonSubstring[i - 1][j - 1] + 1 : 0)的推导关系，这样就可以以动态规划的思想来解答该题了。
C++ Code：
class Solution {
public:
/*
* @param A: A string
* @param B: A string
* @return: the length of the longest common substring.
*/
int longestCommonSubstring(string A, string B) {
// write your code here
if (A == "" || B == "")
return 0;
int sizeA = A.size();
int sizeB = B.size();
int longest = 0;
vector<vector<int> > list(sizeA, vector<int>(sizeB, 0));
int initIndex = 0;
for (int i = 0; i < sizeB; i++) {
list[initIndex][i] = (A[initIndex] == B[i] ? 1 : 0);
}
for (int i = 0; i < sizeA; i++) {
list[i][initIndex] = (A[i] == B[initIndex] ? 1 : 0);
}
for (int i = 1; i < sizeA; i++) {
for (int j = 1; j < sizeB; j++) {
list[i][j] = (A[i] == B[j] ? list[i - 1][j - 1] + 1 : 0);
}
}
for (int i = 0; i < sizeA; i++) {
for (int j = 0; j < sizeB; j++) {
if (longest < list[i][j])
longest = list[i][j];
}
}
return longest;
}
};
Python：解题思路与C++版本相同，直接贴代码。
Python Code：
class Solution:
"""
@param: A: A string
@param: B: A string
@return: the length of the longest common substring.
"""
def longestCommonSubstring(self, A, B):
# write your code here
if (len(A) == 0 or len(B) == 0):
return 0
longest = 0
list = [[0 for i in range(len(B))] for j in range(len(A))]
for i in range(len(B)):
if A[0] == B[i]:
list[0][i] = 1
for i in range(len(A)):
if A[i] == B[0]:
list[i][0] = 1
for i in range(1, len(A)):
for j in range(1, len(B)):
if A[i] == B[j]:
list[i][j] = list[i - 1][j - 1] + 1
for i in range(len(A)):
for j in range(len(B)):
if list[i][j] > longest:
longest = list[i][j]
return longest
题目：最长公共前缀
题目难度：中等
题目描述：
给k个字符串，求出他们的最长公共前缀(LCP)。
解题思路：
C++：没有什么难点，注意判断几个特殊情况即可，例如传入的字符串个数为0，或传入的字符串中存在长度为0的字符串。
C++ Code：
class Solution {
public:
/*
* @param strs: A list of strings
* @return: The longest common prefix
*/
string longestCommonPrefix(vector<string> strs) {
// write your code here
string LCP;
if (strs.size() == 0)
return LCP;
for (int i = 0; i < strs[0].length(); i ++) {
for (int j = 1; j < strs.size(); j++) {
if (strs[j] == "")
return LCP;
if (strs[j].length() < i + 1)
return LCP;
if (strs[0][i] != strs[j][i])
return LCP;
}
LCP += strs[0][i];
}
return LCP;
}
};
Python：与C++的解题思路一致，直接上代码：
Python Code：
class Solution:
"""
@param: strs: A list of strings
@return: The longest common prefix
"""
def longestCommonPrefix(self, strs):
# write your code here
if len(strs) == 0:
return ""
if len(strs) == 1:
return strs[0]
minlength = min([len(s) for s in strs])
for i in range(minlength):
for j in strs:
if strs[0][i] != j[i]:
return strs[0][0: i]
return strs[0][0: minlength]
题目：转换字符串到整数
题目难度：困难
题目描述：
实现atoi这个函数，将一个字符串转换为整数。如果没有合法的整数，返回0。如果整数超出了32位整数的范围，返回INT_MAX(2147483647)如果是正整数，或者INT_MIN(-2147483648)如果是负整数。
解题思路：
C++：此题的难点主要在于需要考虑很多种情况，非常容易遗漏，需要考虑的情况有：传入的字符串长度为零；字符串前几位为‘ ’；正负号情况；字符串中间出现的非数字；数字大于INT_MAX或小于INT_MIN。
C++ Code：
class Solution {
public:
/*
* @param str: A string
* @return: An integer
*/
int atoi(string str) {
// write your code here
int index = 0;
while (str[index] == ' ')
index++;
int number = 0, sign = 1;
if (str[index] == '-' || str[index] == '+') {
sign = str[index] == '-' ? -1: 1;
index++;
}
for (; index < str.size(); index++) {
if (str[index] >= '0' && str[index] <= '9') {
if (number > INT_MAX / 10 || (number == INT_MAX / 10 && str[index] - '0' > 7))
return sign == 1 ? INT_MAX: INT_MIN;
number = number * 10 + (str[index] - '0');
}
else
return number * sign;
}
return number * sign;
}
};
Python：解题思路与C++一致。
Python Code：
class Solution:
"""
@param: str: A string
@return: An integer
"""
def atoi(self, str):
# write your code here
index, number, sign = 0, 0, 1
intmax, intmin = (1 << 31) - 1, -1 << 31
if str == "":
return number
while str[index] == ' ':
index += 1;
if str[index] == '-' or str[index] == '+':
if str[index] == '-':
sign = -1
index += 1
while index < len(str) and str[index] >= '0' and str[index] <= '9':
if number > intmax / 10 or (number == intmax / 10 and ord(str[index]) - ord('0') > 7):
return intmax if sign == 1 else intmin
number = number * 10 + ord(str[index]) - ord('0')
index += 1
return number * sign
备注：本人非常乐意分享我的文章，转载请注明我的博客地址：http://www.cnblogs.com/matthewli/与原文地址：http://www.cnblogs.com/matthewli/p/7376738.html，谢谢！