记录部分热题top100比较好理解(不是最快解)的题解和个人注释
🔥热题top100
1. 两数之和：哈希表
哈希表的迭代器是一个指针it
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
//创建哈希表
unordered_map <int,int> hashtable;
for(int i = 0;i < n;i++)
{
//查
auto it = hashtable.find(target - nums[i]);
//如果find()存在于哈希表，则返回迭代器it，如果不存在则返回表的末尾：hashtable.end()
if(it != hashtable.end()) return {it->second,i};
//哈希表表示为(first second)
//对应(key,value),映射成数组可以理解为(值,下标)
//添加:hashtable[key] = value;
//通过键来查值
hashtable[nums[i]] = i;
}
return {};
}
};2. 两数相加：单链表
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
//创建一个可以返回listNode*的方法,l1/l2是两条链的头结点指针
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
//创建头尾结点指针，头结点指针负责初始化链和返回链，尾结点负责移动存取（next）
ListNode* head = nullptr;
ListNode* tail = nullptr;
//进位数curry
int curry = 0;
//取数变量n1n2，求和数sum
int n1,n2,sum;
//遍历l1l2，只要其中有一条当前结点不为空仍然继续循环
while(l1 || l2)
{
//取数
n1 = l1 ? l1->val : 0;
n2 = l2 ? l2->val : 0;
//求和
sum = n1 + n2 + curry;
//如果head为空，则初始化，不为空则添加并移动尾结点
if(!head)
{
head = tail = new ListNode(sum % 10);
}
else
{
tail->next = new ListNode(sum % 10);
tail = tail->next;
}
//计算进位值，至少先sum一次才能计算进位，第一次默认为0
curry = sum / 10;
//判断是否为空并移位，如果为空也没关系，上面取数的时候会赋0
if(l1)
{
l1 = l1->next;
}
if(l2)
{
l2 = l2->next;
}
}
//循环结束之后最后还要看是否有进位值（最高位）
if(curry > 0)
{
tail->next = new ListNode(curry);
}
//返回
return head;
}
};3. 无重复字符的最长子串：类似哈希表的桶/哈希集合
//方法1：类哈希表桶
class Solution {
public:
int lengthOfLongestSubstring(string s) {
//创建桶(数组)，设定128个元素对应0-127ASCII码值，全部赋0
vector<int> m(128, 0);
//存最大长度
int maxlen = 0;
//head表示窗口最左边的字母序号：如果出现重复的，比如两个相同的字母a，上一个a在桶里存的m[s[i]]是a+1表示a的下一个位置
//那么第二个a出现时，head就=a+1也就是max(head,m[s[i]])，去除了窗口里上一个a，保证窗口里无重复字母
int head = 0;
//遍历字符串
for (int i = 0; i < s.size(); i++) {
//修改最左边的字母序号head
head = max(head, m[s[i]]);
//当前字母对应的ASCII码桶里存下一个位置(i+1)，用于更新head
m[s[i]] = i + 1;
//更新长度
maxlen = max(maxlen, i - head + 1);
}
return maxlen;
}
};//方法2：哈希集合
class Solution {
public:
int lengthOfLongestSubstring(string s) {
unordered_set<char> hashset;
int len=s.size();
int left=0,maxstr=0;
for(int i=0;i<len;i++)
{
while(hashset.find(s[i]) != hashset.end())
{
hashset.erase(s[left]);
left++;
}
hashset.insert(s[i]);
maxstr=max(maxstr,i-left+1);
}
return maxstr;
}
};5. 最长回文子串：动态规划
动态规划，二维数组
class Solution {
public:
string longestPalindrome(string s) {
int len = s.size();
//长度小于2，只有一个字符，单字符是回文的
if(len < 2)
{
return s;
}
//字串从1个字符开始
int maxlen = 1;
//截取开始下标：最后截取的时候用
int begin = 0;
//二维vector数组的创建
/*vector< vector<int> > dp(n, vector<int>(n) );
定义了一个vector容器，
元素类型为vector<int>，
初始化为包含n个vector<int>对象，
每个对象都是一个新创立的vector<int>对象的拷贝，
而这个新创立的vector<int>对象被初始化为包含n个0。*/
vector<vector<int>> dp(len,vector<int>(len));
//i代表左边界，j代表右边界
//对角线ii相当于i=j左边界等于右边界，即为单个字符，所以为true
for(int i = 0;i < len;i++)
{
dp[i][i] = true;
}
//动态规划相当于填写一张二维的表
//而回文子串需要判断s[i]==s[j]，如果相等，就要继续判断去掉两边的中间字串是不是回文
//若中间字串长度小于2，也就是等于1，那么必然是回文，也就是(j-1)-(i+1)+1<2
//也就是j-i<3，也可以写成j-i+1<4,理解为：原长度为3或者2或者1，那么必定为回文串
//另外，如果不满足j-i<3，就需要进一步判断字串是不是回文串s[i+1]...s[j-1]
//参考的值dp[i][j]= (s[i]==s[j] &&（s[i+1][j-1] || j-i<3）)
//s[i+1][j-1]也就是参考左下角
//而第零列dp[0][0]没有右上角，所以j从1开始，从左向右，i从0开始，从上到下开始判断，
//每次都要先看看左下角
for(int j = 1;j < len;j++)
{
for(int i = 0;i < j;i++)
{
if(s[i] != s[j])
{
dp[i][j] = false;
}
else
{
if(j-i+1 < 4)
{
dp[i][j] = true;
}
else
{
dp[i][j] = dp[i+1][j-1];
}
}
//更新最长子串的头尾下标
if(dp[i][j] && j-i+1 > maxlen)
{
maxlen = j-i+1;
begin = i;
}
}
}
//截取最长字串
s = s.substr(begin,maxlen);
return s;
}
};6. N 字形变换：二维矩阵
class Solution {
public:
string convert(string s, int numRows) {
int n = s.length(), r = numRows;
if (r == 1 || r >= n) {
return s;
}
//每个周期t有r+r-2个字符
int t = r * 2 - 2;
//因为int会去尾，所以需要将长度凑成最长n+t-1，t-1（一个周期-1），不然有些最后一个周期不满的时候会被去尾
//(n + t - 1) / t得周期数，r-1是每个周期占用的列数，得c：矩阵列数
int c = (n + t - 1) / t * (r - 1);
vector<string> mat(r, string(c, 0));
for (int i = 0, x = 0, y = 0; i < n; ++i) {
mat[x][y] = s[i];
//判断下一个位置的走向
//i<r-1（竖着画）
if (i % t < r - 1)
{
// 向下移动
++x;
}
//i到r-1或者大于竖着画的个数了
else
{
--x;
++y; // 向右上移动
}
}
string ans;
//用row遍历容器mat，&意思是只读
for (auto &row : mat) {
//用ch遍历row，看看是否有效（不为空）
for (char ch : row) {
if (ch) {
ans += ch;
}
}
}
return ans;
}
};7. 整数反转
// 将数字 digit 推入 rev 末尾rev = rev * 10 + digit
−2^31≤rev*10+digit≤2^31−1 可以推导成 rev < INT_MIN / 10 || rev > INT_MAX / 10
class Solution {
public:
int reverse(int x) {
int rev = 0;
while (x != 0) {
if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
return 0;
}
int digit = x % 10;
x /= 10;
rev = rev * 10 + digit;
}
return rev;
}
};8. 字符串转换整数 (atoi)：自动机
class Automaton{
string state = "start";
//用哈希表画了一个字符串映射字符串数组的自动机
unordered_map<string, vector<string>> table = {
{"start", {"start", "signed", "in_number", "end"}},
{"signed", {"end", "end", "in_number", "end"}},
{"in_number", {"end", "end", "in_number", "end"}},
{"end", {"end", "end", "end", "end"}}
};
//写一个取下标的函数
int getindex(char c)
{
//isspace判断是否是空（空格或者换行符等等都算空）
if(isspace(c)) return 0;
if(c=='+'||c=='-') return 1;
//isdigit判断是否为0-9数字
if(isdigit(c)) return 2;
return 3;
}
public:
//符号
int sign = 1;
//long和int一般都是32位(4字节)，longlong为64位(8字节)
long long ans = 0;
//写了一个取字符串的字符并进位累加的函数
void get(char c)
{
state = table[state][getindex(c)];
if (state == "in_number") {
//字符串或者字符-'0'代表转string/char转int类型(ascii)
ans = ans * 10 + c - '0';
ans = sign == 1 ? min(ans, (long long)INT_MAX) : min(ans, -(long long)INT_MIN);
}
else if (state == "signed")
sign = c == '+' ? 1 : -1;
}
};
class Solution {
public:
int myAtoi(string s) {
Automaton automaton;
for (char c : s)
automaton.get(c);
return automaton.sign * automaton.ans;
}
};9. 回文数：一半数字/**整数反转**
解法1：取后一半数字和前一半数字比较
class Solution {
public:
bool isPalindrome(int x) {
// 特殊情况：
// 如上所述，当 x < 0 时，x 不是回文数。
// 同样地，如果数字的最后一位是 0，为了使该数字为回文，
// 则其第一位数字也应该是 0
// 只有 0 满足这一属性
if (x < 0 || (x % 10 == 0 && x != 0)) {
return false;
}
int revertedNumber = 0;
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
// 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
// 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
// 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
return x == revertedNumber || x == revertedNumber / 10;
}
};解法2：整数反转（挺快的）
利用第7题的溢出控制 完成整数反转比较原数
当然也可以直接longlong防止溢出(doge)
class Solution {
public:
bool isPalindrome(int x) {
int temp = x;
if(x<0 ||(x%10==0&&x!=0)) return false;
int rev = 0;
while (x != 0) {
if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
return 0;
}
int digit = x % 10;
x /= 10;
rev = rev * 10 + digit;
}
return rev==temp;
}
};番外题
连续的非严格递增字序列数组：三指针/贪心
朋友分享的美团javascript一面面试题，这边给一个c++解和一个javascript解
大意是给你个数组，让你返回一个连续的最长非严格递增子序列数组
vector<int> ans;
int head, tmp, tail;
vector<int> numarr = { 37,2,3,4,4,9 };
//用哈希表管理用三指针遍历时遇见的所有连续递增下标，key是头，value就是尾
unordered_map<int,int> hashtable;
int maxkey = 0;
int maxvalue = 0;
int len = numarr.size();
void printArray(vector<int> &numarr,vector<int> &ans)
{
//三指针
head = 0;
tmp = 0;
tail = 0;
hashtable[0] = 0;
while (tail < len-1)
{
tail++;
if (numarr[tail] > numarr[tmp])
{
tmp++;
hashtable[head] = tail;
}
else
{
tmp=tail;
head=tail;
hashtable[head] = tail;
}
}
for (auto a : hashtable)
{
int key = a.first;
int value = a.second;
if (value - key + 1 > maxvalue - maxkey + 1)
{
maxvalue = value;
maxkey = key;
}
}
for (int i = 0; i < maxvalue - maxkey+1; i++)
{
cout << numarr[maxkey+i];
}
}贪心算法javascript
var findLengthOfLCIS = function(nums) {
let maxhead = 0;
let maxtail = 0;
let ans = 0;
const n = nums.length;
let start = 0;
for (let i = 0; i < n; i++)
{
if (i > 0 && nums[i] <= nums[i - 1])
{
start = i;
}
if (ans < i - start + 1)
{
ans = i - start + 1;
maxhead = start;
maxtail = i;
}
}
var arr = new Array();
for (let i = 0; i < ans; i++)
{
arr[i] = nums[maxhead+i];
}
return arr;
};
447
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
