挑战坚持每天写算法题一个月

nums1 [:] = nums1[:m]

nums2 [:] = nums2[:n]

然后我们在把这两个数组给加到nums1这个数组中！！

nums1[:] = nums1 +nums2

然后我们就可以用随便一种排序算法将这个数组排序，我就演示冒泡排序了。

代码

class Solution:

def merge(self, nums1, m: int, nums2, n: int) -> None:

nums1[:] = nums1[:m]

nums2[:] = nums2[:n]

nums1[:] = nums1 + nums2

length = len(nums1)

for i in range(length - 1): # 共有length -1趟排序

flag = True # falg用于记录一趟冒泡排序中，是否有逆序发生

for j in range(1, length - i):

if nums1[j - 1] > nums1[j]:

flag = False # 有逆序发生

nums1[j - 1], nums1[j] = nums1[j], nums1[j - 1]

if flag == True:

break

return nums1

其他思路

其实排序这个算法是O（n）了效率不是很高，如果用双指针就能提高很多的效率复杂度就变成O（m+n），我先说我写这个题的过程，我一共用了三个思路，前两个都有问题，我直接裂开了，从6.00写到10.00，真是一杯茶，一支烟，一道力扣写一天。我的第一个思路是创建一个新的内存，我但是没有看清题意然后就直接创建一个新的地址，然后就提交的时候发现pycharm和力扣的结果总是不一样，我都怀疑力扣出问题了，然后我才知道我不能创建新的地址，所以我手写了第二种思路，但是我又犯了一个致命的错误，就是每次添加数组的长度会改变，然后这个没办法判断下标，其实这个可以从右向坐移动指针，来很有效的解决这个问题，这个问题还是我现在在写这个博客的时候，去大佬群里一个大佬给了我提醒，我真的是菜的垃圾呀，一个初级算法我能写好几个小时，所以这次更要加油了！！

接下来我给大家看一下我写的第二个思路的手稿！！！

今天虽然就写了一题，但是我觉得我进步还是非常大的，如果每天坚持下去，我相信我能收获更多！！！

2021-10-9

=========

题目

–

数组中的重复数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例一：

输入：

[2, 3, 1, 0, 2, 5, 3]

**输出：**2 或 3

二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例一：

[

[1,   4,  7, 11, 15],

[2,   5,  8, 12, 19],

[3,   6,  9, 16, 22],

[10, 13, 14, 17, 24],

[18, 21, 23, 26, 30]

]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例一：

**输入：**s = “We are happy.”

输出：“We%20are%20happy.”

解题思路

---

数组中的重复数字

这个算是一个超级简单的算法题，但是我写这个题简直了呀，开始不想用暴力解法，然后写了半小时，发现越来学懵逼，然后最后用暴力解法，但是！！！！暴力解法超时就很难受！！！

所以我就看了官方的一个题解，我看完以后就是真的很简单，我简直服了我这个智商，是用python间的几行代码就能完成的事我写了半个小时，哭了呀家人！！

话不多说直接上题解：

我们首先可以创建一个set集合，因为集合是不能重复的，所以我们在对列表nums进行一个循环，判断nums元素是否在set中，如果不在就添加，如果在了就表明这个元素是列表中重复的元素，我们就可以直接返回。

总体来说这个题很简单，并不是很难的一个题，还是得多练。

二维数组中的查找

这个题在python中其实能卡一个bug----用 in 一下子就出来了，时间复杂度也是n。

但是我们刷算法的目的是什么？就是为了最优的解决这个问题，让它的效率最大化！！

所以我们不应该取巧的。

这个题主要的思路就是以右上角开始，如果目标变量比右上角的数小，就向左移一列，如果目标标量比右上角的数大就下一移动到下一行的数组中，由此来判断，最后是否能够在这个二维数组里面找到这个目标变量！

两者的复杂度：

接下来我就给大家把这这两个的代码都放在上面！！

替换空格

这个空格替换是一个非常非常简单的题，但是！！！为什么简单还要出这个题？

这个应为算法就是为了找到最优解，找到效率最高的一个效率。

这个题在python中在用一个内置函数replace就可以解决，但是这就没有什么意思了。

还有一个思路就是我们用for 循环来判断这个字符串，在创建一个新的空字符，我们判断如果是空就给空字符（‘%20’）.jion如果不是就直接加入这个字符串就没有什么问题。

接下来直接看代码就完事。

代码

–

合并两个有序数组

class Solution:

def findRepeatNumber(self, nums: List[int]) -> int:

dict = set()

for num in nums:

if num in dict:

return num

else:dict.add(num)

二维数组的查找

一：

class Solution:

def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:

for i in matrix:

if target in i:

return True

else:

return False

二：

class Solution:

def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:

if len(matrix) == 0 :

return False

l_len = len(matrix)

h_len = len(matrix[0])

l = 0

h = h_len-1

while l<l_len and h>=0:

if target<matrix[l][h]:

h -=1

elif target>matrix[l][h]:

l += 1

else:

return True

else:

return False

空格的替换：

class Solution:

def replaceSpace(self, s: str) -> str:

res = []

for c in s:

if c == ’ ': res.append(“%20”)

else: res.append©

return “”.join(res)

总结：

---

2021-10-9.

总结今天的成果，目前是上午一道下午一道晚上一道，本来晚上可以在写一道，但是我的链表这一一块很差，我就抽时间看看链表吧，感觉今天在写这两题的时候收获很多，尤其查找二维数组的这个新思路，我觉得很让我有一个新的思路，可能这就是刷算法题的魅力吧，感觉越刷越上瘾，而且我还比较喜欢在本子上先把思路写一遍然后在整理到 lc 上面我觉得每天刷力扣题也好，每天写一个博客也好，慢慢养成的话，我会觉得这是一个好习惯，对以后的工作啥的帮助肯定会很大，所以只要一有时间我就来刷题，卷起来就完事！！！

给大家分享一下我的笔记，虽然有点丑哈哈哈哈。

2021-10-10

==========

题目

–

1.从尾到头打印链表

例如：[1,5,6,8,6]

输出：[6,8,6,5,1]

2.链表的排序

3.反转列表

这个题和之前写的差不多，都是把链表反转，那个一个题是用列表输出，这个是直接输出链表，难度其实不大，我用了python和c来写的，因为c的指针我不是很熟练，我就写了很久，才把这个简单的题给写出来，所以直接看题解吧。

题解

–

1.从尾到头打印链表：

①：这个在python中我们可以创建一个新的列表，然后遍历这个链表，把这个链表的值都给存储到列表中，在根据python语言的特性，用【：：-1】直接倒叙输出。

②：还有一种就是我们可以用栈，栈的特点不就是只能在表的末尾操作，我们可以先把链表入栈，然后出栈，出栈的的元素放在一个新的数组中，这样就可以完成链表的倒叙。

③：我开始打算用c语言去写这个链表的倒叙输出，但是我c语言的链表基础不是很扎实，还得复习，我还是把c语言的思路给大家。我们可以先创建一个新的链表，然后在获取原来链表的长度，然后在用原链表的末尾开始添加到新列表中。

2.链表的排序：

①：先讲一下这个算法题的目的是让我们给链表排序，但是最多的复杂度是n log（n）用一些暴力解法肯定是不行了，就算是冒泡排序可能也会超时，那该用什么办法呢？

我们其实可以用归并排序的，把每个节点变成空然后排序在用指针链接起来。这个效率是挺高的，但是我链表的基础不是很好，我就没有写出来，还在琢磨中，但是我用了第二种方法。

②：我用的这种方法说实话有点取巧的意思，用到了python的一个内置函数，我觉得写算法题能不用内置函数就别用，毕竟是优化算法题，不是完成项目，写不出来的时候可以试一下。我这次就用了，用了以后我看他的时间复杂度是挺低的，超过了百分之99的人，但是我一点也没有成就感，毕竟不是自己写的算法，而是调用别人的，那也话不多说，直接上思路。

首先我们可以遍历这个链表然后读取每一个元素并给他存储到一个新的列表中，然后在给列表排序，排序完后在创建一个新的链表并直接把新元素存取到这个新的链表中并返回链表，这样就大功告成了。最后还是建议大家能不用第二种方法就不用第二种方法。

3.反转链表：

①：我们先说c语言的方法。首先我们先创建两个指针，用双指针遍历这个链表，然后就把原来的指针给转变为反向的指针，然后就遍历完成就直接返回新的链表，就出来了。

②：我们再来讲python，python是我在最开始写的这个题因为我开始没有弄懂链表，所以就用的python的语言特性写的，还是那句话，能少用语言特性就少用语言特性，毕竟这个题考察的不是语言特性，而是你的算法思路，我准备在写一遍用python，等写出来在把新的补上，这次就将就着看吧。

代码

–

1.从尾到头打印链表

Definition for singly-linked list.

class ListNode:

def init(self, x):

self.val = x

self.next = None

class Solution:

def reversePrint(self, head: ListNode) -> List[int]:

list1 = []

while head:

list1.append(head.val)

head = head.next

return list1[::-1]

2.链表的排序

Definition for singly-linked list.

class ListNode:

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

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;
  

• };

*/

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

struct ListNode * r = head;

while®{

if (head -> val==val ){

return head -> next ;

}

if (r ->next == NULL){

r = NULL;

return head;

}

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

r ->next = r -> next ->next;

return head;

}

r = r -> next;

}

return NULL;

}

3.分隔链表：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* partition(struct ListNode* head, int x){

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

struct ListNode *p1 = p1head;

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

struct ListNode *p2 = p2head;

while (head){

if (head -> val < x){

p1 -> next = head;

p1 = p1 -> next;

}

else{

p2 -> next = head;

p2 = p2 -> next;

}

head = head -> next;

}

p2 -> next = NULL;

p1 -> next = p2head -> next;

return p1head ->next;

}

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

class Solution:

def lengthOfLongestSubstring(self, s: str) -> int:

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

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

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

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

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

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）

t ;

}

if (r ->next == NULL){

r = NULL;

return head;

}

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

r ->next = r -> next ->next;

return head;

}

r = r -> next;

}

return NULL;

}

3.分隔链表：

/**

• Definition for singly-linked list.

• struct ListNode {

• int val;
  

• struct ListNode *next;
  

• };

*/

struct ListNode* partition(struct ListNode* head, int x){

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

struct ListNode *p1 = p1head;

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

struct ListNode *p2 = p2head;

while (head){

if (head -> val < x){

p1 -> next = head;

p1 = p1 -> next;

}

else{

p2 -> next = head;

p2 = p2 -> next;

}

head = head -> next;

}

p2 -> next = NULL;

p1 -> next = p2head -> next;

return p1head ->next;

}

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

class Solution:

def lengthOfLongestSubstring(self, s: str) -> int:

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

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

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

[外链图片转存中…(img-MqUaytIq-1712757541697)]

[外链图片转存中…(img-x41wrR4u-1712757541698)]

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

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

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）