挑战坚持每天写算法题一个月(1)-CSDN博客

本文链接：https://blog.csdn.net/2401_84010497/article/details/138090738

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:

if not s : return 0

looku = set()

left = 0

max_len = 0

cur_len = 0

for i in range(len(s)):

cur_len += 1

while s[i] in looku:

looku.remove(s[left])

left += 1

cur_len -=1

looku.add(s[i])

if max_len < cur_len:

max_len = cur_len

return max_len

总结

总算在夜深人静的时候写到今天的总结，虽然写博客很累，但是我觉得这个累只是上天再给你通向成功之路的一个考验，我们应该学会享受这种累，虽然身体很累，但是心里的成就感还是挺满足的，今天一共刷了四题，两个简单的，两个mid，我觉得对我自己的算法思路又有了新的提升，今天已经是第六天了，我觉得从刷算法题到现在我能坚持每天刷题和写博客，自己是在成长的路上，也是在变强的路上，我相信如果我坚持这一年，我一定会到达我的目标，会有一个更好的未来，所以，星光不问赶路人，时光不负有心人！！！加油奥里给！！！

2021-10-14

==========

题目

–

1.山峰数组的顶部

2.回文链表

3.重排列表

4.未知题目

这个是我一个刷题朋友发我的，也是我今天最后刷的一个算法题，我也直接给大家看看。

题解

–

1.山峰数组的顶部

这个题是今天LC的每日一题，程度是简单的，这个题不难，用一个哈希表就立马出来了，把每个元素的的下表都存储在字典里面，然后找出最大值并返回它对应的值，这个题就直接出来了哦！！！

2.回文链表

这个有一个很简单的思路，就是直接先把链表放在数组里面然后在数组里面判断是否是回文链表，就直接用数组里面的判断返回这个布尔值就可以了。

3.重排链表

这个和上面第二个思路有点类似，把链表的元素都取出来，然后就直接使用双指针进行插入链表中，然后在返回链表就可以。

还有一个解法就是直接把一个链表分成两个链表，然后直接再用一个指针去链接就可以，这个方法复杂度还是比较低的，不过我没用这个算法，大家可以直接试一试！

4.未知题目

这个题我觉得不是很难一个双指针就出来了可能在LC中就是一个easy的题吧，直接用双指针我就不过多解释了，大家看代码就能看懂，其实写出来还挺舒服的，用py写算法题就是舒服呜呜呜呜呜。。。。。。

代码

–

1.山峰数组的顶部

class Solution:

def peakIndexInMountainArray(self, arr: List[int]) -> int:

dit = {}

index = 0

for i in arr:

dit[i] = index

index += 1

return dit[max(dit)]

2.回文链表

bool isPalindrome(struct ListNode* head) {

int vals[50001], vals_num = 0;

while (head != NULL) {

vals[vals_num] = head->val;

vals_num ++;

head = head->next;

}

for (int i = 0, j = vals_num - 1; i < j; ++i, --j) {

if (vals[i] != vals[j]) {

return false;

}

return true;

}

3.重排链表

/**

Definition for singly-linked list.
struct ListNode {
```
int val;
```
```
struct ListNode *next;
```
};

void reorderList(struct ListNode* head){

if (head == NULL){

return;

}

struct ListNode *vals [40001];

struct ListNode *node = head;

int len = 0;

while(node){

vals[len] = node;

len++;

node = node -> next;

}

int i = 0, j = len - 1;

while(i<j){

vals[i]->next = vals[j];

i++;

if (i == j){

break;

}

vals[j]->next = vals[i];

j–;

}

vals[i] -> next = NULL;

}

4.未知题目

list1 = []

n = [6,2,7,3,2]

slow = 0

fast = 1

d = 0

while slow <len(n):

if fast <len(n):

if n[slow] >= n[fast]:

fast += 1

d += 1

else:

list1.append(d+1 )

slow += 1

fast += 1

d = 0

else:

list1.append(-1)

slow += 1

fast += 1

print(list1)

总结

–

怎么评价今天呢？还真是五谷杂陈，今天上午没有课我看组元就直接看的挺懵逼的，又觉得我选个的这个专业去大厂可能有点困难，所以我就迷茫了，我也怀疑过我每天刷题的目的，究竟是为了什么去刷题？？今天也是挺迷茫的一天，没有人倾述，只能憋在心里，所以说在变强的路上是孤独的，我们要学会享受这种孤独，习惯孤独，我很喜欢有一句话——**耐得住寂寞，守得住繁华。**这句话是先有寂寞在又繁华，没有体会孤独又怎么让你有守住繁华的心呢？所以我现在是在这个寂寞的路上，要耐住寂寞，沉静身心勇往之前，拼就完事。

我现在最喜欢的事情就是——在雨天耳机一带，打开LC开始我的刷题之路，就好比如世界和我隔绝我这个时候只有我自己！！！！

还有今天的笔记嘿嘿嘿嘿嘿嘿嘿

2021-10-15

题目

–

1.环形链表

2.输入有序数组

3.找到所有消失的数组

题解

–

1.环形链表

我们可以用龟兔算法来轻松解决这个问题，先看下面的图，能更好的理解这个问题。

这个是我嫖官方的图嘿嘿嘿嘿嘿，如果是一个环形链表的话，当乌龟和兔子都进入了这个环形链表中，兔子比乌龟快，总有一次，乌龟能和兔子相遇，但是如是不是环形链表的话，兔子就已经跑出去这个链表的范围，兔子这个指针就是空链表了，所以我们可以由此来写代码表达这个算法！

2.输入有序数组

这个题是我的二刷了，这个题我最开始是用的暴力解法，但是今天看到这个题又想再去尝试尝试，所以又重新来写了一遍，这次用的是双指针，突然就感觉这个题用双指针写出来就很舒服的感觉，就证明自己在进不了。下面直接上解题思路了！

我们先可以定义两个指针solw和fast 用fast来做快指针，用slow从头开始，fast 比slow快一个，然后，创建要给while循环，直到solw等于数组的长度减一的时候就退出循环，在循环里面写一个if判断，如果快慢指针的值相加后等于目标函数，则返回s两者下表，如果没有相等就直接让fast加一，如果fast超过了数组的长度，那就让slow进行下一个元素，如果while循环结束后还没有返回值就证明没有找到这个值，然后在下面加一个return [-1,-1]，这样任务就结束了。

3.找到所有消失的数组

我用的方法太简单了，我都不想写这个题解了，我看官方还有一个先排序在寻找的办法，这个是我没有想到的，我觉得是挺牛的，可以学习学习，今天这题大家直接看代码就能理解了，我也不多说啥了！

代码

–

1.环形链表

bool hasCycle(struct ListNode* head) {

if (head == NULL || head->next == NULL) {

return false;

}

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

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

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

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

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

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

松解决这个问题，先看下面的图，能更好的理解这个问题。

这个是我嫖官方的图嘿嘿嘿嘿嘿，如果是一个环形链表的话，当乌龟和兔子都进入了这个环形链表中，兔子比乌龟快，总有一次，乌龟能和兔子相遇，但是如是不是环形链表的话，兔子就已经跑出去这个链表的范围，兔子这个指针就是空链表了，所以我们可以由此来写代码表达这个算法！

2.输入有序数组

这个题是我的二刷了，这个题我最开始是用的暴力解法，但是今天看到这个题又想再去尝试尝试，所以又重新来写了一遍，这次用的是双指针，突然就感觉这个题用双指针写出来就很舒服的感觉，就证明自己在进不了。下面直接上解题思路了！

我们先可以定义两个指针solw和fast 用fast来做快指针，用slow从头开始，fast 比slow快一个，然后，创建要给while循环，直到solw等于数组的长度减一的时候就退出循环，在循环里面写一个if判断，如果快慢指针的值相加后等于目标函数，则返回s两者下表，如果没有相等就直接让fast加一，如果fast超过了数组的长度，那就让slow进行下一个元素，如果while循环结束后还没有返回值就证明没有找到这个值，然后在下面加一个return [-1,-1]，这样任务就结束了。