字节跳动 算法面试题挑战坚持每天写算法题一个月，2024最新大厂Python面试真题解析

self.val = val

self.next = next

class Solution:

def sortList(self, head: ListNode) -> ListNode:

list1 = []

head1 = head

while head1:

list1.append(head1.val)

head1 = head1.next

list1[:] = sorted(list1)

i = 0

t = head

while t:

t.val = list1[i]

t = t.next

i += 1

return head

#我就只写出来了一种，第一种方法大家可以自己去尝试一下。

3.链表的反转

①：c语言：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* reverseList(struct ListNode* head){

struct ListNode * p1 = head;

if (head == NULL){

    return head;

}

struct ListNode *p2 = head ->next;

struct ListNode *c = NULL;

p1->next = NULL;

while (p2){

    c = p1;

    p1 = p2;

    p2 = p2->next;

    p1->next = c;

}

return p1;

}

②：python：

Definition for singly-linked list.

class ListNode:

def init(self, val=0, next=None):

self.val = val

self.next = next

class Solution:

def reverseList(self, head: ListNode) -> ListNode:

    list1 = []

    head1 = head

    while head1:

        list1.append(head1.val)

        head1 = head1.next

    list1[:] = list1[::-1]

    i = 0

    t = head

    while t:

        t.val = list1[i]

        t = t.next

        i += 1

    return head

总结

–

2021-10-10

今天主要是对链表的练习，加深和掌握链表，第一题其实是昨天没有写出来的一道题，然后今天看了大佬们的解题思路，然后才了解python中的链表，但是c语言中的链表我还是只能看懂，并不能直接写出来，这个就是我现在的不足地方，所以我的路还很长，任重而道远！！！

今天也收获到一句话：

2021-10-11

==========

题目

–

1.合并两个有序数组

2.删除链表倒数的第N个节点

3.两两交换链表中的节点

题解

–

1.合并两个有序数组：

这题其实是一个很简单的问题，就是把两个链表里面的数值进行比较，返回一个新的有序链表，话不多说我们直接说步骤。

我们首先创建一个新的空链表，然后定义两个链表的指针 p1 和 p2，就从第一个链表的指针开始说，拿链表一里面的一个数值和第二个链表的第一个数值比较，如果第一个大，新指针就指向 p2中的值，然后p2指针向下移动，反之，同上。直到 p1 和 p2里面中有一个为空就跳出循环，然后在对两个指针分别进行判断，如果谁为空，新指针就指向另外一个，并且直到新指针返指到空，然后返回新链表。

以上就是这题的解题思路！大家也可以参考参考，如有错误希望指正，感激不尽！

2.删除链表倒数的第N个节点

这个题是我第二次刷到，因为最近学链表，所以又刷了一次，而且两次写题的方法还不同，这是我觉得我进步的地方吧，话不多说我就直接分享题解了！

①：第一种方法就是我最开始写的一种方法：

先遍历链表的长度，然后从后向前循环，循环n次，然后删掉该节点，删除后直接返回该链表就可以。

②：第二种方法是双指针的思路，我们可以先创建两个指针slow和fast，然后在让fast向前移动n+1个地址，等fast移动完后开始让两个指针同时向右移动，直到fast为空，此时slow的位置在倒数第n个的左边一个，然后在用 if进行判断，如果fast为空，slow ->next = slow ->next-> next.就就直接跳过该倒数第****n个节点，然后在对slow进行循环，但是slo为空时返回slow，这样就完成了该目的。

借鉴了官方的图像

总结一下：①的时间复杂度是L，②的时间复杂度也是L，但是我觉得双指针跟舒服一些。

3.两两交换链表中的节点

两两交换可以用迭代，这个我不知道怎么去表述我的解法，我表述的可能不是很明白，大家可以去看lc的官方解题，那个挺详细的。我就直接上代码了！

代码

–

1.合并两个有序数组：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){

struct ListNode * p1 = l1;

struct ListNode *p2 = l2;

struct ListNode t = (struct ListNode)malloc(sizeof(struct ListNode));

struct ListNode *r3 = t;

while (p1&&p2){

if ((p1 ->val) <= (p2 ->val)){

r3 ->next = p1;

r3 = p1;

p1 = p1 ->next;

}

else{

r3 ->next = p2;

r3 = p2;

p2 = p2 ->next;

}

}

if (p1 == NULL ){

r3 ->next = p2;

}

else if (p2 == NULL){

r3 ->next = p1;

}

return t ->next;

}

2.删除链表倒数的第N个节点

①：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* removeNthFromEnd(struct ListNode* head, int n){

struct ListNode *fast=head;

struct ListNode *slow=head;

while(fast!=NULL&&(n–)>0){

fast=fast->next;

}

while(fast!=NULL&&fast->next!=NULL){

fast=fast->next;

slow=slow->next;

}

struct ListNode *q;

if(fast==NULL){

q=head;

head=head->next;

free(q);

}else{

q=slow->next;

slow->next=q->next;

free(q);

}

return head;

}

②：

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {

struct ListNode* dummy = malloc(sizeof(struct ListNode));

dummy->val = 0, dummy->next = head;

struct ListNode* first = head;

struct ListNode* second = dummy;

for (int i = 0; i < n; ++i) {

first = first->next;

}

while (first) {

first = first->next;

second = second->next;

}

second->next = second->next->next;

struct ListNode* ans = dummy->next;

free(dummy);

return ans;

}

3.两两交换链表中的节点

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* swapPairs(struct ListNode* head){

struct ListNode dummyHead;

dummyHead.next = head;

struct ListNode *temp = &dummyHead;

while(temp->next!= NULL && temp->next->next!=NULL) {

struct ListNode* n1 = temp ->next;

struct ListNode *n2 = temp ->next -> next;

temp -> next = n2;

n1 ->next = n2 ->next;

n2 -> next =n1;

temp = n1;

}

return dummyHead.next;

}

总结

–

最后来总结一下今天的成果吧，今天是我这个学期第一次去教室上课，而且今天的课比较多白天基本上都是满课，但是我也是在物理课和数据库的实验课上面写了算法题，最开始在英语课上面写了三个算法解题思路，然后回寝室准备想给他直接写完，但是！！我发现我写的太乱了，我直接看不懂了，这不等于白瞎了嘛，我直接当场去世呀！！最后也是在数据库的实验课把思路找了回来，其中有一题因为我的思路把代码写出来了，就会超时，所以那一道题没有写出来，准备打算明天再看看，今天的课是比较多的，明天的课还很多，真是压力山大呀，晚上累的更新博客就花了我两个小时，最后这段话写完了，我还要复习我的计算机组成原理，我现在感觉我超级累，但是，我也觉得我很充实，为了能拿到大厂的暑假实习机会，我不能停！！！将来的我肯定会感谢现在的我！

--------2021-10-11

2021-10-12

==========

题目

–

1.基本计算器（进阶）

在此基础上还要有乘法和除法运算，这个题在力扣上面只有这个基础的运算加括号，但是我们今天数据结构老师上课讲课这个思路，直接到题解部分吧。

2.两数相除

3.删除排序链表中的重复元素

4.移除链表元素

题解

–

1.基本计算机（进阶）

这个题有很多种思路，比如单栈，双栈等，因为我们老师讲的是双栈思路，我就直接看的是双栈思路，今天我只弄懂了python的双栈思路，等明天我在研究一下c语言的写法，这个在力扣算是困难模式，所以以我现在的表达并不能讲明白，我建议大家还是去 LC搜 基本计算器这个题，有基本的思路，我在这就直接上代码了。

2. 两数相除

这个题是今天2021-10-12的每日推荐题，开始我以为我用辗转相减法给可以写出来，但是我还是太年轻，我对这个题差点弄自闭，下面给大家看一下我的提交结果。

当时我真想当场去世，最后实在没思路，也没用官方的思路去写，我在评论区看到一个简单的思路，我就借鉴了一下，原理和二倍乘差不多，备注在代码上，大家直接看代码就可以了!

3.删除排序链表中的重复元素

这个题非常简单一个指针足以，开始我的思路是用双指针去写，然后我看完官方的题解我才发现我的思路很复杂。

这个思路就是前后比较，然后如果相同就直接跳过，如果不相同，指针继续向右走，直到为空！

4.移除链表元素

这个题也是链表里面的基础题，这个最开始我也是用双指针表去写的，官方还是用的单指针，效率是挺高的，所以这个题解大家看代码就可以看懂，就不用我来一一给大家讲了。

代码

–

1.基本计算机（进阶）

class Solution:

op_map = {

‘-’ : 1,

‘+’ : 1,

‘*’ : 2,

‘/’ :2

}

def cal(self,nums,otp_stack):

if len(nums)<2 or not otp_stack:

return

a = nums.pop()

b = nums.pop()

res = 0

otp = otp_stack.pop()

if otp == ‘+’:

res = a + b

elif otp == ‘-’:

res = b -a

elif otp == ‘*’:

res = a*b

elif otp == ‘/’:

res = b / a

nums.append(res)

def calculate(self,s):

s = s.replace(’ ‘, ‘’).replace(’(-‘, ‘(0-’).replace(’(+', ‘(0+’)

nums = [0]

otp_stack = []

n = len(s)

i = 0

while i <=n -1:

if s[i].isdigit():

num = int(s[i])

i += 1

while i <= n-1 and s[i].isdigit() :

num = num*10 +int(s[i])

i += 1

nums.append(num)

continue

elif s[i] == ‘(’:

otp_stack.append(s[i])

elif s[i] == ‘)’:

while otp_stack[-1] != ‘(’:

self.cal(nums,otp_stack)

otp_stack.pop()

else:

while otp_stack and otp_stack[-1] != ‘(’ and self.op_map[otp_stack[-1]] >= self.op_map[s[i]]:

self.cal(nums, otp_stack)

otp_stack.append(s[i])

i += 1

while otp_stack:

self.cal(nums,otp_stack)

return nums[-1]

2. 两数相除

class Solution:

def divide(self, dividend: int, divisor: int) -> int:

将被除数和除数转化为正数

sign = 1

if divisor * dividend < 0: # 如果符号不同，则结果返回要变成负数

sign = -1

divisor = abs(divisor)

dividend = abs(dividend)

elif divisor < 0 and dividend < 0: # 如果被除数和除数都是负值，结果不修改符号

divisor = abs(divisor)

dividend = abs(dividend)

remain = dividend # 余数

result = 0 # 商

while remain >= divisor:

cur = 1 # 倍增商

div = divisor # 倍增值

while div + div < remain:

cur += cur

div += div

remain -= div # 余数递减

result += cur # 商值累计

if sign==-1:

result = -result

if result>=2**31: # 按照题目要求，溢出处理

result = 2**31-1

return result

3.删除排序链表中的重复元素

struct ListNode* deleteDuplicates(struct ListNode* head){

if (!head){

return head;

}

struct ListNode * fast = head;

while (fast -> next){

if ((fast -> val) == (fast ->next ->val)){

fast ->next = fast ->next -> next;

}else{

fast = fast -> next;

}

}

return head;

}

4.移除链表元素

struct ListNode* removeElements(struct ListNode* head, int val){

struct ListNode *dump =malloc(sizeof(struct ListNode));

dump->next = head;

struct ListNode *temp = dump;

while (temp -> next){

if (temp -> next -> val == val){

temp -> next = temp -> next -> next;

}

else {

temp = temp -> next;

}

}

return dump->next ;

}

总结

–

最后还是总结一下今天的结果，加今天也是第5天了，每天基本上都是三道题，我觉得刷题这个东西还真上瘾呢，比上课还有舒服，我喜欢在本子上面写我思路的过程，但是每次思路写出来都不是完全没问题还有一定的逻辑问题，或者思路有问题，这个又得到电脑面前更正或者看题解，这段时间虽然很短，但是我能感觉我在进步，我对基础算法，已经在慢慢得了解，我觉得这个习惯每天都坚持下去，我到大三的的时候离我的目标肯定也不远了，但是现在效率太低，想思路，改思路，改代码错误，都太费时间了，所以还是得找到一个效率高的办法去写，今天写了四蹄，收获很多，我希望，我能一直坚持下去，相信自己，加油！！！！！

2021-10-13

==========

题目

–

1.Fuzz，Buzz

2.删除链表节点

3.分隔链表

4.无重复字符的最长字串

题解

–

1.Fuzz，Buzz：

这个题目就是直接一个对除数的判断，太过简单我就直接不说啥了，还是今天的每日一练的题目。

2.删除链表节点：

这个就是一个for循环加上三个if判断语句，然后如果遇到目标值val直接让指针跳过就可以，这个题也是很简单的，我看LC直接懒得给官方答案。

3.分隔链表：

这个题是一个很有意思的题，开始我还没有把思路给想出来，但是我看了官方的解法简直又是给我一个新的天地，直接两个链表一个用来存储大于等于目标值的，一个用来存储比目标值小的，LC还有一个作者做了动态演示，大家可以去看看。最后在把两个表链接起来就成功了！！

4.无重复字符的最长字串：

这个题是我之前没有写出来的一个滑块题，因为它的滑块长度是会变化的，最开始我有点把握不住这个长度，看了一些大佬的题解才写出来的。

由于我的表达太差，我还是直接给大家上官方的题解思路吧。

代码

–

1.Fuzz，Buzz：

class Solution:

def fizzBuzz(self, n: int) -> List[str]:

map = [‘Fizz’,‘Buzz’,‘FizzBuzz’]

list1 = []

for i in range(1,n+1) :

if i % 3 == 0 and i%5 == 0:

list1.append(map[2])

elif i % 3 == 0:

list1.append(map[0])

elif i % 5 == 0:

list1.append(map[1])

else:

list1.append (str(i))

return list1

2.删除链表节点：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：

①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

1a671c1fb70aad5355a2c5eeff0.png)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）
[外链图片转存中…(img-CTqZt10K-1712298352441)]

感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：

①　2000多本Python电子书（主流和经典的书籍应该都有了）

②　Python标准库资料（最全中文版）

③　项目源码（四五十个有趣且经典的练手项目及源码）

④　Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）

⑤ Python学习路线图（告别不入流的学习）

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算