转至：https://blog.csdn.net/Uupton/article/details/84640146

今天登陆leetcode发现探索区多了字节跳动的专栏，特意用了一下午去刷，有些是之前刷过的。但题目不错，就当是复习一遍吧，这里记录一下我会的以及自己觉得不错的题目。

原题链接请点击题目

一：挑战字符串

3. 无重复字符的最长子串

分析：这题要求连续的不重复的最长子序列的长度，注意这里是需要连续，利用这个特性，我们可以维护一个窗口，窗口装的是无重复的字符串，一开始窗口的左边在起点(即下标为0处)。我们用 i 遍历字符串，如果当前字符没有出现过或者当前字符虽然出现过但不在当前的窗口，则窗口向右扩张。而当当前字符出现在窗口内，则窗口的左边收缩到当前字符前一个出现的位置。详见代码

class Solution {
public:
int lengthOfLongestSubstring(string s) {
//维护一个滑动窗口，最大的窗口大小即为结果
int hash[128] = {0};
int left = 0,res = 0;
for(int i = 0;i<s.size();i++)
{
if(hash[s[i]] == 0||hash[s[i]]<left) //1：没出现过 2：出现过但没在窗口内
res = max(res,i-left+1); //不断更新res值
else
left = hash[s[i]]; //窗口内出现重复，缩小左边窗口
hash[s[i]] = i+1;
}
return res;
}
};

14. 最长公共前缀

简单题，以第一个字符串作为模版，逐个拿出模版的每个字符，然后其余的字符串也逐个拿出相对应位置的字符比较是否相同。注意字符串长度的问题即可。

class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
if(strs.empty()) return "";
string res = "";
for(int i = 0;i<strs[0].size();i++)
{
char c = strs[0][i]; //逐个拿出模版字符串的字符
for(int j = 1;j<strs.size();j++) //后面的字符串
{
if(i>=strs[j].size()||strs[j][i]!=c) //当i已经超过字符串的长度或者字符不相同时直接返回
return res;
}
res+=c;
}
return res;
}
};

567. 字符串的排列

分析：对s2全排再一一跟s1对比肯定会超时。所以我们可以维护两个窗口，一个窗口装s1，另一个窗口装s2。假设s1长度为len1,s2长度为len2。开始先分别装s1和s2的前lne1个字符进各自的窗口。如果此时两个窗口相等则直接返回true，如果不等则s2的窗口从len1开始装s2的字符，同时窗口的左边要删除一个元素，因为两个窗口要保持大小，期间如果两个窗口相等则返回true

class Solution {
public:
bool checkInclusion(string s1, string s2) {
//v1、v2维护一个大小相同的窗口，先计算出len1前的字符出现的次数，如果相等直接返回TURE，如果不等则操作v2继续往后走，后面的字符添上，窗口左边的字符删除
int len1 = s1.size(),len2 = s2.size();
vector<int> v1(128,0),v2(128,0);
for(int i = 0;i<len1;i++)
{
v1[s1[i]]++;
v2[s2[i]]++;
}
if(v1==v2) return true;
for(int i = len1;i<len2;i++) //v2从len1位置开始装
{
v2[s2[i]]++; //装新的字符
v2[s2[i-len1]]--; //删除早装入的字符
if(v1 == v2)
return true;
}
return false;
}
};

43. 字符串相乘

分析：这里主要开了三个数组来做，一个数组存第一个字符串，另一个数组存第二个字符串，最后一个数组存结果。保存两个字符串的时候要反着顺序存，因为我们平时做乘法的时候也是从数字的最后一位向前乘的，所以其实这道题主要是模拟了平时在纸上做的乘法。

class Solution {
public:
string multiply(string num1, string num2) {
int x[120] = {0},y[120] = {0},z[250] = {0};
int len1 = num1.size(),len2 = num2.size();
for(int i = len1-1,k = 0;i>=0;i--)
x[k++] = num1[i]-'0';
for(int i = len2-1,k = 0;i>=0;i--)
y[k++] = num2[i]-'0';
for(int i = 0;i<len1;i++) //在这里进行相乘，但没进位
{
for(int j = 0;j<len2;j++)
z[i+j] += (x[i]*y[j]);
}
for(int i = 0;i<249;i++) //现在进位
{
if(z[i]>9)
{
z[i+1] += z[i]/10;
z[i]%=10;
}
}
int i;
for(i = 249;i>=0;i--)
if(z[i] != 0)
break;
string res = "";
for(;i>=0;i--)
res+=(z[i]+'0');
if(res == "") return "0";
return res;
}
};

151. 翻转字符串里的单词

分析：主要做法就是先把整个字符串反转，然后开始遍历字符串，每遍历完一个单词（注意不是一个字符）的时候将这个单词再反转。

class Solution {
public:
void reverseWords(string &s) {
int index = 0,n = s.size();
reverse(s.begin(),s.end()); //反转整个字符串
for(int i = 0;i<n;i++)
{
if(s[i]!=' ') //遇到非空格的字符
{
if(index!=0)
s[index++] = ' ';
int j = i; //令j = i 进行下面的操作
while(j<n&&s[j]!=' ') //遍历完整一个单词
s[index++] = s[j++];
reverse(s.begin()+index-(j-i),s.begin()+index); //对刚才遍历的单词进行反转
i = j;
}
}
s.resize(index);
}
};

93. 复原IP地址

分析：一般题目问字符串有多少种可能的排列，十有八九都是用递归做的。我们需要先写一个函数判断一个字符串是否符合ip其中一个结点，符合的标准：1、1到3位长度的字符串。2、长度大于一的话首位不能为0。3、整数大小要在0~255的范围内。

接着就可以递归做正式工作。这里对字符串分别截取一位、二位、三位。。。判断是否能构成ip的一个结点，如果能的话就截断这部分，让剩余的部分递归下去继续做判断。

具体看代码

class Solution {
public:
vector<string> restoreIpAddresses(string s) {
vector<string> res;
// string out = "";
helper(res,s,"",4);
return res;
}
void helper(vector<string>& res,string s,string out,int k)
{
if(k==0)
{
if(s.empty()) //注意点一，原字符串s应该要为空了
res.push_back(out);
}
else
{
for(int i = 1;i<=3;i++)
{
//截取某部分进行判断，如果合法则进入下一个递归
if(s.size()>=i&&isValid(s.substr(0,i))) //注意点二，越界判断
{
if(k==1) //k==1代表当前ip再添加多一个结点就够四个了
helper(res,s.substr(i),out+s.substr(0,i),k-1);
else
helper(res,s.substr(i),out+s.substr(0,i)+'.',k-1);
}
}
}
}
//判断是否合法
bool isValid(string s)
{
if(s.empty()||s.size()>3||(s.size()>1&&s[0]=='0'))
return false;
int num = atoi(s.c_str());
return num>=0&&num<=255;
}
};

二、数组与排序

15. 三数之和

class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> res;
sort(nums.begin(),nums.end());
for(int i = 0;i<nums.size();i++)
{
if(nums[i]>0) break;
if(i>0&&nums[i] == nums[i-1])
continue;
int target = 0-nums[i];
int j = i+1,k = nums.size()-1;
while(j<k)
{
if(nums[j]+nums[k] == target)
{
res.push_back({nums[i],nums[j],nums[k]});
while(j<k&&nums[j+1] == nums[j]) j++;
while(j<k&&nums[k-1] == nums[k]) k--;
j++;k--;
}
else if(nums[j]+nums[k]<target)
j++;
else
k--;
}
}
return res;
}
};

674. 最长连续递增序列

class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
int res = 0,cnt = 0;
int cur = INT_MAX;
for(int num:nums)
{
if(num>cur)
cnt++;
else cnt = 1;
res = max(res,cnt);
cur = num;
}
return res;
}
};

三、链表与树

2. 两数相加

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
int add = 0;
ListNode* res = new ListNode(0);
ListNode* head = res;
while(l1||l2||add)
{
int num = (l1?l1->val:0)+(l2?l2->val:0)+add;
head->next = new ListNode(num%10);
head = head->next;
add = num/10;
l1 = l1?l1->next:l1;
l2 = l2?l2->next:l2;
}
return res->next;
}
};

148. 排序链表

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* sortList(ListNode* head) {
if(!head||!head->next) return head;
ListNode* slow = head,*fast = head,*pre = head;
while(fast&&fast->next)
{
pre = slow;
slow = slow->next;
fast = fast->next->next;
}
pre->next = NULL;
return merge(sortList(head),sortList(slow));
}
ListNode* merge(ListNode* a,ListNode* b)
{
ListNode* head = new ListNode(0);
ListNode* node = head;
while(a&&b)
{
if(a->val<b->val)
{
node->next = a;
a = a->next;
}
else
{
node->next = b;
b = b->next;
}
node = node->next;
}
if(a) node->next = a;
if(b) node->next = b;
return head->next;
}
};

142. 环形链表 II

/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode* fast = head;
ListNode* slow = head;
while(fast&&fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
break;
}
if(!fast||!fast->next) return NULL;
slow = head;
while(fast != slow)
{
slow = slow->next;
fast = fast->next;
}
return fast;
}
};

236. 二叉树的最近公共祖先

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(!root||p==root||q==root) return root;
TreeNode* left = lowestCommonAncestor(root->left,p,q);
TreeNode* right = lowestCommonAncestor(root->right,p,q);
if(left&&right) //p和q分别位于左右子树中
return root;
return left?left:right;
}
};

四、动态或贪心

121. 买卖股票的最佳时机

class Solution {
public:
int maxProfit(vector<int>& prices) {
int res = 0,buy = INT_MAX;
for(auto c:prices)
{
buy = min(buy,c);
res = max(res,c-buy);
}
return res;
}
};

122. 买卖股票的最佳时机 II

class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
if(len<=1)
return 0;
vector<int> have(len);
vector<int> unhave(len);
have[0] = -prices[0];
int res = 0;
for(int i = 1;i<len;i++)
{
unhave[i] = max(unhave[i-1],have[i-1]+prices[i]);
have[i] = max(have[i-1],unhave[i-1]-prices[i]);
res = max(res,unhave[i]);
}
return res;
}
};

221. 最大正方形

class Solution {
public:
int maximalSquare(vector<vector<char>>& matrix) {
if(matrix.empty()||matrix[0].empty()) return 0;
int m = matrix.size(),n = matrix[0].size();
vector<vector<int>> dp(m,vector<int>(n,0));
int res = 0;
for(int i = 0;i<m;i++)
{
for(int j = 0;j<n;j++)
{
if(i == 0||j == 0)
dp[i][j] = matrix[i][j]-'0';
else if(matrix[i][j] == '1')
dp[i][j] = min(min(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1])+1;
res = max(res,dp[i][j]);
}
}
return res*res;
}
};

LeetCode——字节跳动系列题目相关推荐

【2023秋招】10月9日字节跳动校招题目
完整真题解析:[2023秋招]10月9日字节跳动校招题目以及满分解析第一题题目内容给定一个大小为 nnn 的数组 aaa , 其中 aia_iai 代表从 111 号节点到 iii 号节点的最 ...
字节跳动校招题目——找零问题
题目描述 Z国的货币系统包含面值1元.4元.16元.64元共计4种硬币,以及面值1024元的纸币.现在小Y使用1024元的纸币购买了一件价值为N(0<N≤1024)的商品,请问最少他会收到多少硬 ...
leetcode 买卖股票系列题目总结
总结:买卖股票系列题目 1.买卖股票的最佳时机(简单) 121. 买卖股票的最佳时机难度简单1093 给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格. 如果你最多只允许完成一笔交易( ...
【2023秋招】10月9日字节跳动校招题目以及满分解析
第一题题目内容给定一个大小为 nnn 的数组 aaa , 其中 aia_iai 代表从 111 号节点到 iii 号节点的最短路.现在需要你设计一张由 nnn 个节点. mmm 条边组成的无向连 ...
leetcode——石子游戏系列题目
石子游戏亚历克斯和李用几堆石子在做游戏.偶数堆石子排成一行,每堆都有正整数颗石子 piles[i] . 游戏以谁手中的石子最多来决出胜负.石子的总数是奇数,所以没有平局. 亚历克斯和李轮流进行,亚历 ...
LeetCode 1195. Fizz Buzz Multithreaded--并发系列题目--Java 解法--AtomicInteger/CountDownLatch/CyclicBarrier
题目地址:Fizz Buzz Multithreaded - LeetCode Write a program that outputs the string representation of nu ...
offer收割机: 字节跳动、YY、虎牙、BIGO
推荐:一个非常强的小哥哥, 逆袭成功-- 作者:lienjack https://juejin.im/post/5e85ec79e51d4547153d0738 由于微信禁止外链,为了更好的阅读体验, ...
2 年前端面试字节跳动、YY、虎牙、BIGO心路历程总结
作者 | LienJack 来源 | https://juejin.im/post/5e85ec79e51d4547153d0738 本文将先从个人背景讲起,然后谈谈在字节跳动.虎牙.YY 以及 BI ...
LienJack-2年前端面试心路历程（字节跳动、YY、虎牙、BIGO）
LienJack-2年前端面试心路历程(字节跳动.YY.虎牙.BIGO) 大厂面经字节跳动 1 面对 tree-shaking 的了解虽然生产模式下默认开启,但是由于经过 babel 编译全部模 ...

LeetCode——字节跳动系列题目

一：挑战字符串

二、数组与排序

三、链表与树

四、动态或贪心

LeetCode——字节跳动系列题目相关推荐

最新文章

热门文章