力扣刷题0630

已于 2023-06-30 17:16:44 修改
阅读量78 收藏
点赞数
分类专栏： python 文章标签： leetcode 算法 职场和发展
于 2023-06-30 17:10:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41975611/article/details/131468685
版权

文章目录

链表理论基础

链表（单链表）是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

链表的入口节点称为链表的头结点也就是head。
在这里插入图片描述

链表的分类

链表可以分为：单链表、双链表、循环链表。

单链表中的指针域只能指向节点的下一个节点。
双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。
双链表 既可以向前查询也可以向后查询。
在这里插入图片描述
循环链表，就是链表首尾相连。循环链表可以用来解决约瑟夫环问题。
在这里插入图片描述

链表的存储方式

链表的存储方式跟数组不同，数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

链表常用操作

1、删除节点：（Python，就有自己的内存回收机制，不用自己手动释放）
在这里插入图片描述
2、添加节点：
在这里插入图片描述对比数组：
在这里插入图片描述
数组在定义的时候，长度就是固定的，如果想改动数组的长度，就需要重新定义一个新的数组。链表的长度可以是不固定的，并且可以动态增删， 适合数据量不固定，频繁增删，较少查询的场景。
注意：通常单链表的定义如下：

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

203.移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

题目链接：链接

自己理解题目：先想着用两个指针在链表上操作，发现只能删第一个满足要求的节点；后面就采用链表+列表的形式实现，即只在列表中存入满足要求的节点值，然后将列表转换成链表，比较迂回了。。。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        #cur=head
        #res=ListNode(-1)
        #res.next=cur
        #if head==None:
        #    return None
        #while cur:
        #    if cur.val==val:
        #        res.next=cur.next  #删除节点后，cur和res指向同一个节点
        #    cur=cur.next
        #    res=res.next
        #
        #return head     
        l=[]
        cur=head
        
        while cur:
            if cur.val!=val:
                l.append(cur.val)
            cur=cur.next
        curl=ListNode(-1)
        res=ListNode(-1)
        res.next=curl
        for i in range(0,len(l)):
            curl.next=ListNode(l[i])
            curl=curl.next
        return res.next.next

题解：

 pre=ListNode()   #定义一个虚节点
        pre.next=head   #虚节点的下一节点为头节点
        cur=pre         #定义当前节点变量
        while cur.next: #当当前节点下一节点不为空节点时开始循环，保证3个节点都存在
            if cur.next.val==val:       #下一节点满足删除条件
                cur.next=cur.next.next  #删除当前节点
            else:                       #不满足要求时
                cur=cur.next                #往后循环链表
        return pre.next  #返回虚节点

一看题解，自己把单链表的删除想太复杂了。。。

707.设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
题目链接：

自己理解题目：说实话，题目我都读不懂。。。就当混个眼熟吧

（版本一）单链表法
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
        
class MyLinkedList:
    def __init__(self):
        self.dummy_head = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
            
        return current.val

    def addAtHead(self, val: int) -> None:
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1

    def addAtTail(self, val: int) -> None:
        current = self.dummy_head
        while current.next:
            current = current.next
        current.next = ListNode(val)
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:#这里不是>=
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val, current.next)
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

（版本二）双链表法
class ListNode:
    def __init__(self, val=0, prev=None, next=None):
        self.val = val
        self.prev = prev
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        
        if index < self.size // 2:
            current = self.head
            for i in range(index):
                current = current.next
        else:
            current = self.tail
            for i in range(self.size - index - 1):
                current = current.prev
                
        return current.val

    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val, None, self.head)
        if self.head:
            self.head.prev = new_node
        else:
            self.tail = new_node
        self.head = new_node
        self.size += 1

    def addAtTail(self, val: int) -> None:
        new_node = ListNode(val, self.tail, None)
        if self.tail:
            self.tail.next = new_node
        else:
            self.head = new_node
        self.tail = new_node
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index - 1):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index):
                    current = current.prev
            new_node = ListNode(val, current, current.next)
            current.next.prev = new_node
            current.next = new_node
            self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        if index == 0:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev
            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            current.prev.next = current.next
            current.next.prev = current.prev
        self.size -= 1

206.反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

题目链接：链接

自己理解题目：第一反应利用列表的reverse反转后，转化成链表。

（版本一）双指针法
# 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:
        cur = head   
        pre = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp
        return pre

（版本二）递归法
# 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:
        return self.reverse(head, None)
    def reverse(self, cur: ListNode, pre: ListNode) -> ListNode:
        if cur == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur)

每次碰到链表问题，都是固定思维转化成列表操作再转链表，改改改。

..verifier
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
"力扣刷题"通常指的是用户通过反复练习这些题目来提高自己的编程能力。 在力扣上刷题的过程中，你可以接触到以下几个核心知识点： 1. **数据结构**： - 数组：基础的数据结构，用于存储固定大小的同类型元素集合...
力扣刷题精选11111
03-23
《力扣刷题精选11111》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它聚焦于LeetCode平台上的算法题目，涵盖了数据结构与算法、职场技能和职业发展等多个方面。LeetCode作为全球知名的在线编程挑战平台，...
力扣刷题思路
m0_74212228的博客
11-09 578
力扣刷题思路
力扣刷题之准备工作
weixin_47040031的博客
05-01 1049
在刷算法题的过程中进行总结是非常重要的，它可以帮助你梳理思路、加深理解、记录学习成果，并提升解题能力。每天回顾：在每天结束时，对当天解决的题目进行回顾。检查解决方案的正确性，并思考是否有更优化的方法。记录下遇到的难点和解决方法，以及学到的新知识点和技巧。整理这些笔记并归档到适当的分类中，以便今后参考。每周汇总：在每周末或开始新一周时进行总结。复习过去一周解决的题目，分析解题过程中使用的算法和数据结构。总结你学到的关键知识点、解题技巧和模式，并将其整理到博客中。
力扣刷题指南
qq_42535301的博客
04-03 4078
跟着视频“手把手刷力扣”先听知识点讲解，然后把下面的经典题做了（每个系列≤4道（2easy 2medium)），接着听视频里的题目讲解。 再去刷hot100/top100，一个系列共刷10-20道 按先后顺序刷系统 争取刷200道左右 先：数组，字符串，链表，数学，栈，哈希表，图，树 后：排序，动态规划，贪心，递归，二分，双指针，深广度优先，sliding window，回溯 笔记需要记录： 思路与误区 语法：如三元表达式、最大堆 总结出的刷题模板：如union find,trie 不熟悉的知识点：.
力扣刷题策略
不落的博客
09-28 584
作为一个计算机科学技术研究者，编程能力一定要过硬才行，因为在实际学习工作中难免要进行大量地编程敲代码，而力扣题提供了一个非常好的编程环境锻炼自身的编程能力，尤其是数据结构与算法。算法思想包括定义、边界信息、分治、贪心、动态规划、回溯、分支限界、归纳、逆向。刷题建议按照难度从易到难的顺序进行，即分治、贪心、回溯、分支限界、动态规划、定义、边界信息、归纳、逆向。数据结构包括线性表，栈，队列，串，树，图，查找，排序，哈希表，堆，集合。刷题按照以上顺序刷即可。刷题策略为先刷数据结构，再刷算法思想。
力扣刷题c++常用函数
hm__2016的博客
03-13 523
find(vec.begin(), vec.end(), target) == vec.end() (找不到）getline(cin,s6);读入带空格的字符串 读取字符到遇到换行，空格可读入，‘\n’直到结束。1.3 s.find_first_of（str） 和 s.find_last_of（str）dp[i][j] – 背包重量为j， 物品1-i件时的最大价值。其与 01背包题的差别仅仅是把状态转移方程中的。1.4查找目标字符串在字符串出现的总次数。读入字符串不能带空格。1.正向查找find（）
力扣刷题笔记
kuyugoing的博客
05-26 521
力扣刷题笔记：二分法、滑动窗口、链表经典题目。
力扣刷题篇——排序
weixin_59796310的博客
06-04 1482
力扣刷题篇——排序
力扣刷题（c语言）
m0_61562743的博客
11-07 939
力扣
力扣刷题汇总
qq_39607707的博客
04-06 1422
动态规划学习
力扣刷题
qq946561354_xgl的博客
03-30 184
3-30 力扣解决动态规划等差数列2题 1）368.最大整除数集 思考：如果满足num[i]%nums[j]==0,那么就可以让这一组数列加1，即dp[i]=dp[j]+1 def largestDivisibleSubset(self, nums: List[int]) -> List[int]: if not nums: return nums if l...
力扣刷题算法截图汇总2021
04-02
2021年的力扣刷题算法截图汇总是一个珍贵的学习资源，它可能包含了当年力扣上的热门问题及其解决方案的截图。由于标签为"python"，我们可以推断这些截图主要涉及使用Python语言解决这些问题。 在Python编程中，解决...
使用力扣刷题的经验.pdf
04-21
本文主要是讲如何使用力扣进行刷题，此文是我根据自己的刷题经验进行编写的，主要针对的用户包括刚刚接触编程的小伙伴，还有就是有一些算法基础想提升自己的算法能力的小伙伴。
leetcode:力扣刷题
03-06
这个“leetcode:力扣刷题”很可能是某个用户或开发者整理的关于在LeetCode上刷题的学习资料或笔记。 标题中提到的“力扣刷题”，暗示了这可能是一个关于如何高效解决LeetCode问题的指南或者是个人的解题经验分享。...
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 644
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
最新发布
qq_26521261的博客
07-20 272
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 276
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
1. LeetCode-数组和字符串
weixin_43149506的博客
07-18 911
数组和字符串介绍以及相关例题
力扣刷题C++常用操作
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值