原题链接：
第一题：把字符串转换成整数
题目：
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
解析：
模拟题，先处理空格，然后处理符号，最后判断字符串中是不是有非数字。
class Solution {
public:
int StrToInt(string str) {
if (str.size() == 0)
return 0;
string digit = "";
for (auto it = str.begin(); it != str.end(); ++it)
if (!isspace(*it))
digit.push_back(*it);
bool f = true;
if (digit[0] == '+' || digit[0] == '-')
f = digit[0] == '+', digit = digit.substr(1);
for (auto it = digit.begin(); it != digit.end(); ++it)
if (isalpha(*it))
return false;
int ret = 0;
for (auto it = digit.begin(); it != digit.end(); ++it)
ret = ret * 10 + *it - '0';
return f ? ret : -ret;
}
};第二题：数组中重复的数字
题目：
在一个长度为
n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
解析：
最容易想到的做法就是下标法哈希一下。这样做的空间复杂度为 O(n) O ( n ) 。
class Solution {
public:
// Parameters:
// numbers: an array of integers
// length: the length of array numbers
// duplication: (Output) the duplicated number in the array number
// Return value: true if the input is valid, and there are some duplications in the array number
// otherwise false
bool duplicate(int numbers[], int length, int* duplication) {
int used[(const int)length], i;
memset(used, false, sizeof(used));
for (i = 0; i < length && !used[numbers[i]]; used[numbers[i++]] = true);
return i == length ? false : (*duplication = numbers[i], true);
}
};有一种空间复杂度为 O(1) O ( 1 ) 的做法，要充分利用题中加粗的这个条件，同样是利用下标哈希，只不过这一次是把当前元素对应下标处的数字加上
n表示这个元素已经出现过了，如果下一次哈希到这个位置发现该位置上的数字大于等于n(由于当前元素可能被别的数字哈希过，故当前元素要对n取模)，这说明之前有同样的数字了，故这个数字就是答案。
class Solution {
public:
// Parameters:
// numbers: an array of integers
// length: the length of array numbers
// duplication: (Output) the duplicated number in the array number
// Return value: true if the input is valid, and there are some duplications in the array number
// otherwise false
bool duplicate(int numbers[], int length, int* duplication) {
int i;
for (i = 0; i < length && numbers[numbers[i] % length] < length; numbers[numbers[i++] % length] += length);
return i == length ? false : (*duplication = numbers[i] % length, true);
}
};第三题：构建乘积数组
题目：
给定一个数组
A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。
解析：
由于不能使用除法，故只能通过累积来计算，一个很直观的方法就是开两个数组，一个从左开始累积，一个从右开始累积，最后对应位置的元素乘起来就行了。
但是仔细想想，会发现从右开始累积的这个数组可以用一个变量代替，也就是说，
B数组先从1计算到n - 1，然后再从n - 2计算到0，这样B数组就是一个答案了。
class Solution {
public:
vector<int> multiply(const vector<int>& A) {
vector<int> B(A.size(), 1);
for (int i = 1; i < (int)A.size(); B[i] = B[i - 1] * A[i - 1], ++i) {}
for (int i = (int)A.size() - 2, tri = 1; i >= 0;
tri *= A[i + 1], B[i] *= tri, --i) {}
return B;
}
};第四题：正则表达式匹配
题目：
请实现一个函数用来匹配包括
'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配
解析：
这个题看起来和深信服2018校园招聘C++工程师编程题 - 题解中的第四题有点像，但是
*的意义不一样，严格来说，这题难度较大一点。如果对这类题没有一点头绪的同学可以先看看深信服的那道校招题先。这里要重点关注这个
*，因为*和前面一个字符有关系，故在判断当前字符时要往后多看一个字符；
而且，要单独判断下*表示没有前面字符的情况，出现1, 2, ...这些可以循环判断。
class Solution {
public:
bool match(const char *str, const char *pattern)
{
int str_len = strlen(str), pattern_len = strlen(pattern);
if (!str_len && !pattern_len)
return true;
if (str_len && !pattern_len)
return false;
if (pattern[0] == '.') {
if (pattern[1] != '*')
return str[0] ? match(str + 1, pattern + 1) : false;
// 0
if (match(str, pattern + 2))
return true;
for (int i = 0; i < str_len; i++)
if (match(str + i + 1, pattern + 2))
return true;
return false;
} else {
if (pattern[1] != '*')
return pattern[0] == str[0] ? match(str + 1, pattern + 1) : false;
// 0
if (match(str, pattern + 2))
return true;
for (int i = 0; i < str_len && pattern[0] == str[i]; i++)
if (match(str + i + 1, pattern + 2))
return true;
return false;
}
}
};后来发现循环判断
*是多余的，只需判断{char}*，{char}出现0次或1次的情况就行了，因为出现两次的情况会在下次递归中出现1次的地方判断，这也是递归可以替代循环的一个例子。只不过，写成循环的形式，更符合我们思考的模式，更容易理解罢了。
class Solution {
public:
bool match(const char *str, const char *pattern)
{
int str_len = strlen(str), pattern_len = strlen(pattern);
if (!str_len && !pattern_len)
return true;
if (str_len && !pattern_len)
return false;
if (pattern[0] == '.') {
if (pattern[1] != '*')
return str[0] ? match(str + 1, pattern + 1) : false;
if (match(str, pattern + 2))
return true;
// for (int i = 0; i < str_len; i++)
// if (match(str + i + 1, pattern + 2))
// return true;
// return false;
return str_len && match(str + 1, pattern);
} else {
if (pattern[1] != '*')
return pattern[0] == str[0] ? match(str + 1, pattern + 1) : false;
if (match(str, pattern + 2))
return true;
// for (int i = 0; i < str_len && pattern[0] == str[i]; i++)
// if (match(str + i + 1, pattern + 2))
// return true;
// return false;
return pattern[0] == str[0] && match(str + 1, pattern);
}
}
};
第五题：表示数值的字符串
题目：
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串
"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
解析：
从题干中可以得知如下信息：
- 字母只能存在
e或E，且最多一个；- 小数点最多一个；
- 如果存在
e或E，那么它左右两边都要有字符；-,+一起最多两个；-或+后面必须跟数字。故预处理时可以排除一些简单情况，然后就是几个综合条件加在一起的判断了，这里判断可以利用乘法原理与枚举法分类讨论，虽然情况比较多，但是思路是清晰的。
还是看代码吧，其实这题细节还是很多的，细节都在代码中，想一次就通过这个题还是有点困难的。
class Solution {
public:
bool isNumeric(char* string)
{
char *it = string, *pe = nullptr, *po = nullptr;
int used[1 << 7] = {0};
for ( ; *it && (isdigit(*it) || (tolower(*it) == 'e' && !used[tolower(*it)]++ && (pe = it)) ||
(*it == '.' && !used[*it]++ && (po = it)) ||
((*it == '+' || *it == '-') && 1 >= used['+'] + used['-'] && ++used[*it])) ;
++it) {}
if (*it)
return false;
if (pe == nullptr)
return !(used['+'] + used['-']) ? true : used['+'] + used['-'] == 1 ? !isdigit(string[0]) : false;
return pe != string && pe[1] && (po == nullptr || pe > po) &&
(!(used['+'] + used['-']) || (1 == (used['+'] + used['-']) &&
(string[0] == '+' || string[0] == '-' || pe[1] == '+' || pe[1] == '-')) ||
(2 == (used['+'] + used['-']) && (string[0] == '+' || string[0] == '-') && (pe[1] == '+' || pe[1] == '-')));
}
};这题的正解是编译原理中的自动机，虽然学过，但是还给老师了，不愿多写代码了，有兴趣的同学可以自行了解。
第六题：字符流中第一个不重复的字符
题目：
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符
"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符"google"时，第一个只出现一次的字符是"l"。如果当前字符流没有存在出现一次的字符，返回#字符。
解析：
这个题最大的特点就是字符流是变化的，字符流中一直有字符插入。也就是说，第一个不重复的字符是时刻在变化的。
由于要求第一个不重复的字符，因此我们准备一个队列，队列中存的是只出现一次的字符，按时间顺序入队；
出队时要注意，队头的元素一定就是答案，有可能在插入的过程中队头元素重复了，因此还要依次判断队头元素，如果出现一次以上，则不符合条件，出队，再判断下一个队头元素；否则队头元素就是答案。
class Solution
{
private:
int used[1 << 7];
queue<char> que;
public:
Solution() {
memset(used, 0, sizeof(used));
}
//Insert one char from stringstream
void Insert(char ch)
{
if (++used[ch] == 1)
que.push(ch);
}
//return the first appearence once char in current stringstream
char FirstAppearingOnce()
{
for (; !que.empty() && used[que.front()] != 1; que.pop()) {}
return que.empty() ? '#' : que.front();
}
};
扫一扫
566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
