目录

前言

 2021-10-8

题目

合并两个有序数组

解题思路

代码

其他思路

2021-10-9

题目

数组中的重复数字

二维数组中的查找

解题思路

数组中的重复数字

二维数组中的查找

代码

总结：

2021-10-10

题目

1.从尾到头打印链表

2.链表的排序

3.反转列表

题解

1.从尾到头打印链表：

2.链表的排序：

3.反转链表：

代码

1.从尾到头打印链表

2.链表的排序

3.链表的反转

总结

2021-10-11

题目

1.合并两个有序数组

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

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

题解

 1.合并两个有序数组：

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

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

代码

 1.合并两个有序数组：

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

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

总结

2021-10-12

题目

1.基本计算器（进阶）

2.两数相除 

题解

1.基本计算机（进阶）

2. 两数相除

代码

1.基本计算机（进阶）

2. 两数相除 

总结

2021-10-13

题目

1.Fuzz，Buzz

2.删除链表节点

题解

1.Fuzz，Buzz：

2.删除链表节点：

代码

1.Fuzz，Buzz：

2.删除链表节点：

总结 

2021-10-14

题目

1.山峰数组的顶部

2.回文链表

题解

1.山峰数组的顶部

2.回文链表

代码

1.山峰数组的顶部

2.回文链表

总结

2021-10-15

题目

1.环形链表

2.输入有序数组

3.找到所有消失的数组

题解

1.环形链表

2.输入有序数组

代码

1.环形链表 

因为最近参加了csdn的一个大博主的活动第一届LeetCode刷题打卡赢现金活动，坚持每天写写力扣算法题一个月，我觉得这个活动很有意义，因为每天能写一道算法题很容易，但是坚持一周呢？一个月呢？一年呢？能坚持的人少之又少，但是如果坚持每天写几道算法题并坚持很久，也是会有很大的收获的，为了自己的目标，我们冲就完事！！！

顺便给大佬谢谢这个大佬提供这个机会！！

大家也可以去大佬的博客看看干货！！！

向大佬学习！！

 2021-10-8

题目

合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例一：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例二：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例三：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

解题思路

首先我们得把两个数组按照指定切片，并且不能创建新的内存。

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(c)
        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(r){
        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;
    struct ListNode* fast = head->next;
    while (slow != fast) {
        if (fast == NULL || fast->next == NULL) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

2.输入有序数组

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        low, high = 0, len(numbers) - 1
        while low < high:
            total = numbers[low] + numbers[high]
            if total == target:
                return [low + 1, high + 1]
            elif total < target:
                low += 1
            else:
                high -= 1

        return [-1, -1]

 3.找到所有消失的数组

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        lst = []
        x = set(nums)
        for i in range(1,len(nums)+1):
            if i not in x:
                lst.append(i)
        return lst

总结

又到了每天的晚上的总结时间嘿嘿嘿！！！！又是忙碌碌的一天，今天也是这哥活动的开始，但是今天都是课，情绪还有点低落，我就没写太多=题，今天还有一个题没有写出来，看了题解然后就因为有点忙就放在一遍了，明天周末可以认真的写一会题了，今天是第八天，坚持了八天，我觉得这次活动的名次对我来说已经不重要了，最重要的是坚持这次活动哦，今天就没太多话，就直接发表了，加油！！！！