力扣练习4.25

92. 反转链表 II

要求在指定的区间内反转。
解题思路:
将整个链表拆成三部分,第一部分是头节点到left的前一个节点,第二部分是left到right的待反转区间,第三部分是right的下一个节点为头结点到尾部。
首先根据反转链表的方法遍历待反转区间的链表,不断修改每个节点的指向。
然后将反转的链表的首尾和第一、三个部分相连接。

步骤:
1.初始化哑结点,将其指向头结点,设置前驱节点,初始化为pre,指向哑结点
2.遍历链表,直到遍历到left的前一个节点,保存为pre
3.设置反转区间的遍历反转变量:前驱节点:start=pre.next;指针节点:cur=start.next
4.在指定区间内反转:根据反转链表的方法
5.此时的start移动到了待反转链表的尾部,反转完成后就是头节点位置;cur移动到了第三部分的头结点;反转完成后的尾部就是待反转链表的头节点,也就是pre.next,这个指针是没有变的。
6.先链接反转链表和第三个区间:将反转完成后的尾部的指针指向第三部分的头结点——pre.next.next = cur
7.链接第一个区间和反转链表:left的前一个节点(第一个区间的尾部)指向反转链表的头结点——pre.next = start
8.返回头结点,是哑结点指向的节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:# 创建哑节点dummy_node = ListNode(-1)dummy_node.next =head# 设置前驱节点pre = dummy_node# 遍历到左界的前一个节点for _ in range(left-1):pre = pre.next# 初始化遍历反转的前驱和指针节点start = pre.nextcur = start.next# 在指定区间内反转链表for _ in range(right-left):temp = cur.next # 临时变量存储指针节点的后继节点cur.next = start # 修改指针节点的指向,指向前驱节点start = cur # 将前驱节点修改为指针节点cur = temp # 将指针节点移动到其后继节点# 拼接三个区间# 这个时候,pre仍指向反转区间的第一个节点,该节点,也就是pre.next已成为为反转区间的尾部# 尾部应该链接cur,因为不断反转后cur指针的位置是在第三个区间的头节点pre.next.next = cur # 完成反转区间和第三个区间的链接# 第二个和第三个区间链接了,现在链接第一个和第二个# 此时的start移动到了反转后链表的头节点,更新第一个区间的尾部节点的指针pre.next = startreturn dummy_node.next

234. 回文链表

解题思路一

将链表的值复制到数组,数组和其逆序比较,相同即为回文。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:# 遍历,形成list,反转list,看两者是否相同list_1 = [] # 正序cur = headwhile cur:list_1.append(cur.val)cur = cur.nextif list_1 == list_1[::-1]:return Trueelse:return False

解题思路二

链表的方式。找到链表的中点;将链表的中点及之后的子链表反转;逐个比较同位置的节点值。
步骤:
1.设置快慢指针,都从头节点开始,快指针一次移动两个单位,慢指针一个单位,当快指针移动到链表末尾时,慢指针位置就是中点。(奇数个节点时是中点,偶数个是中间俩节点的右节点)
2.从中点开始反转,是包括中点的。得到反转后的头节点。
3.以反转后的子链表为基准,和原始链表从头节点开始比较值,全部相同即为回文。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:# 找中点slow, fast = head,head# 遍历,慢指针移动一步,快指针移动两步,循环退出后slow就在中点# 中点被包含在后半部分while fast and fast.next:slow = slow.nextfast = fast.next.next# 反转链表函数,默认操作,返回反转后的头结点pre,cur是下一个区间的头节点def reverse(head):# 前驱节点pre = Nonecur = headwhile cur:temp = cur.nextcur.next = prepre = curcur = tempreturn pre # 返回反转部分的头节点# 反转中点及之后的链表reversed_list = reverse(slow)# 比较原始的链表和反转后的子链表first_list = headflag = True# 以反转后的子链表为基线while reversed_list:# 比较同一位置的值if reversed_list.val != first_list.val:flag = Falsebreak# 同时往后移动reversed_list = reversed_list.nextfirst_list = first_list.next# 返回结果return flag

21. 合并两个有序链表

解题思路:逐步比较两个链表的节点,将较小的节点依次添加进新链表。
步骤:
1.新建哑结点,指针节点指向它。
2.设置循环,直到某一个链表被遍历完。
3.循环体内判断两个链表此时的头节点的大小,将小的节点加到指针节点后面(加在新链表后面)

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:# 哑结点dummy_node = ListNode(-1)# 指针节点cur = dummy_node# 遍历两个链表,当某一个被遍历完成后退出while list1 and list2:# 根据大小排序if list1.val > list2.val:# 将新链表的头节点指向较小的节点cur.next = list2# 移动较小的节点的头节点list2 = list2.nextelse:# 将新链表的头节点指向较小的节点cur.next = list1# 移动较小的节点的头节点list1 = list1.next# 移动指针节点cur = cur.next# 退出后检查某一个链表还没遍历完if list1: # list1没有遍历完,直接将新链表的尾节点指向剩余的list1cur.next = list1if list2: # 同理cur.next = list2# 返回新建链表的头节点return dummy_node.next

148. 排序链表

解题思路:

将链表复制为数组,sort后转为链表。(错误)

从链表的角度考虑,最适合排序的算法就是归并排序。分割+合并。
链表的分割也是找中点,前面的题有过,与前面不同的是,这道题的中点是要包含在前面部分的,所以初始化fast不同;
链表的合并:上一题直接拿过来;
最后弄个主函数将其组合起来,递归进行,每次都找中点,分割出左右子链表,排序,合并。

步骤

1.将以上思路包装为不同的函数
2.找中点函数:fast初始化为fast.next
3.合并有序链表函数
4.主函数:找到中点,趁还没断链,先用mid.next作为右子链表的头节点排序右子链表;断链后对左子链表排序,都是递归进行;最后返回对排序后的链表的归并结果。终止条件是只有一个节点。

# 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: Optional[ListNode]) -> Optional[ListNode]:# 找到中点的函数def get_mid(head):if not head: return head# fast初始化为head.next,使得在偶数情况下循环完成后slow处于中间两个节点靠左slow, fast = head, head.nextwhile fast and fast.next:slow = slow.nextfast = fast.next.nextreturn slow# 有序合并链表的函数(升序)def merge(l1,l2):dummy_node = ListNode(-1)cur = dummy_node# 当两个链表有一个遍历完成,就退出while l1 and l2:if l1.val > l2.val:cur.next = l2l2 = l2.nextelse:cur.next = l1l1 = l1.nextcur = cur.next# 还有剩余的if l1:cur.next = l1if l2:cur.next = l2return dummy_node.next# 主函数,归并排序def merge_sort(head):# 递归出口,没有节点或者只有一个节点,返回自身if not head or not head.next:return head# 获取中点mid = get_mid(head)# 对右子链表排序(递归),mid是要算在左边的,防止只有两个节点的情况right_sorted = merge_sort(mid.next)# 中点断开,获得左子链表,排序mid.next = Noneleft_sorted = merge_sort(head)# 最开始两个子链表分别只有一个元素,逐渐增加也是有序的,转换为合并有序链表return merge(left_sorted, right_sorted)# 启动排序return merge_sort(head)

23. 合并 K 个升序链表

解题思路一

最直观的思路就是以第一个链表为基准,后面的不停的与其合并。
转换为了合并两个有序链表的问题。但是时间复杂度是 O(kN),其中 k 是链表的数量,N 是链表中的节点总数。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:if not lists:return Noneif len(lists)==1:return lists[0]# 合并两个链表def merge(l1,l2):dummy_node = ListNode(-1)cur = dummy_nodewhile l1 and l2:if l1.val > l2.val:cur.next = l2l2 = l2.nextelse:cur.next = l1l1 = l1.nextcur = cur.nextif l1:cur.next = l1if l2:cur.next = l2return dummy_node.next# 初始化,以第一个链表为基准sort_list = lists[0]for i in range(1, len(lists)):sort_list = merge(sort_list, lists[i])return sort_list

解题思路二

分治法,找到中点,区分左右列表,排序。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:if not lists:return Noneif len(lists)==1:return lists[0]# 合并两个链表def merge(l1,l2):dummy_node = ListNode(-1)cur = dummy_nodewhile l1 and l2:if l1.val > l2.val:cur.next = l2l2 = l2.nextelse:cur.next = l1l1 = l1.nextcur = cur.nextcur.next = l1 or l2return dummy_node.next# 分治法# 找中点,区分左右mid = len(lists)//2# 递归调用自身left_list = self.mergeKLists(lists[:mid])right_list = self.mergeKLists(lists[mid:])return merge(left_list, right_list)

解题思路三

最小堆(优先队列)
定义最小堆,初始化为每个链表的头节点,不断将堆顶元素出堆,添加到结果链表中。

步骤:

1.导入heapq模块实现最小堆
2.初始化最小堆,添加每个链表的头节点,包括值、索引、节点本身
3.创建哑结点,作为结果链表的开始
4.当堆不为空,将堆顶元素出堆,添加到结果链表后面
5.如果堆顶元素后面还有值,继续将其入堆
6.返回哑结点.next即为结果链表头节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
import heapq
class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:# 处理为空情况if not lists: return None# 定义最小堆heaq = []# 初始化最小堆,将每个链表的首个节点加入堆for index, node in enumerate(lists):if node:# 将节点值、索引、节点本身入堆heapq.heappush(heaq, (node.val, index, node))# 创建新链表的开始,哑结点dummy = ListNode(-1)cur = dummy# 当最小堆不为空while heaq:# 从最小堆中弹出最小元素(升序)val, idx, node = heapq.heappop(heaq)# 创建新的节点,添加到结果链表的结尾cur.next = ListNode(val)cur = cur.next# 如果当前节点后续还有节点,也入堆if node.next:heapq.heappush(heaq, (node.next.val, idx, node.next))return dummy.next

141. 环形链表

解题思路:快慢指针,快的一次走两步,慢的一步,如果会相等,说明有环。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution:def hasCycle(self, head: Optional[ListNode]) -> bool:# 快慢指针,如果相遇,就说明有环slow, fast = head,head# 循环遍历while fast and fast.next:slow = slow.nextfast = fast.next.next# 如果指针相等,说明有环if slow == fast:return Truereturn False

142. 环形链表 II

解题思路:
两阶段:第一阶段使用快慢指针,找到相遇点,第二阶段重置某个指针,两个指针速度一致,返回指针相遇时的节点。

步骤:
1.初始化快慢指针,找到相遇时的指针状态
2.重置慢指针到头节点,创建循环(当两个指针不相等),返回相遇时的指针所在的节点。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution:def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:# 处理特殊情况if not head or not head.next:return None# 先找到环,此时快慢指针相遇slow, fast = head,head# 找到环while fast and fast.next:slow = slow.nextfast = fast.next.next# 遇到环,终止循环if slow == fast:break# 重置慢指针,将两个指针的速度调相同# 直到快慢指针相遇slow = headwhile slow != fast:slow = slow.nextfast = fast.nextreturn slow

160. 相交链表

解题思路:

最直观的想法是,如果两个链表长度一样,那他们的相交节点就能通过逐个遍历节点找到了。
面对不同长度的链表,怎么才能使其在相交节点之前的长度一样呢?
那就是先遍历完链表1,再遍历链表2.在两个指针分别逆向(a指针遍历链表1-2,b指针遍历链表2-1)遍历,就同步了这两个链表的遍历。使得他们可以在相交点相遇。
时间复杂度O(N+M),其中 N 和 M 是两个链表的长度

步骤:

1.初始化链表a、b的指针
2.创建循环,直到a和b重合。a先遍历链表a,再遍历链表b;b同理
3.重合时的指针a或b即为所求。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = Noneclass Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:# 设置两个链表的指针cur_a,cur_b = headA, headB# 如果两个指针不重合while cur_a != cur_b:# cur_a先遍历链表aif cur_a:cur_a = cur_a.next# 遍历完成后转向遍历belse:cur_a = headB# cur_b同理if cur_b:cur_b = cur_b.nextelse:cur_b = headA# 返回重合时的指针return cur_a

19. 删除链表的倒数第 N 个结点

解题思路:

最开始想两次反转链表,但是只有两个节点的情况下老是过不了(因为我考虑的是至少三个节点),遂放弃。

正确的方法是 快慢指针。先让快指针跑个n+1步,然后让快慢指针一起跑,直到快指针到了末尾,这个时候慢指针就是倒数第n+1个节点。再将其指向改为下下个节点即可。

步骤

1.初始化哑结点,快慢指针指向哑结点
2.快指针移动n+1个
3.快慢指针同时移动到快指针达到末尾
4.将慢指针的指向指向下下个节点

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:# 哑结点dummy = ListNode(0)dummy.next = head# 初始化快慢指针slow = fast = dummy# 快指针先移动n+1步for _ in range(n+1):fast = fast.next# 同时移动快慢指针,当快指针到到末尾,说明慢指针也到达了倒数第n+1个节点while fast:slow = slow.nextfast = fast.next# 将倒数第n+1个节点指向倒数第n-1个节点,倒数第n个节点指向空# n_node = slow.next # 暂存第n个节点slow.next = slow.next.next# n_node.next = None # 将第n个节点指向空return dummy.next

143. 重排链表

解题思路:

可以转换为回文链表的思路。先从中点拆分,再交叉合并。

根据寻找中点的不同,可以分为两种步骤:

步骤1

1.找中点的快慢指针初始化为head,head.next,偶数时处于靠前的中点
2.将中点后的链表作为右子链表,切断左右子链表的链接
3.反转右子链表
4.交叉合并,设置一个哑结点。因为左子链表在奇数时会多一个中点,所以在同时合并两个子链表的前面位数的节点后,还需要加上左边剩余的节点。此时每次循环都分别消耗一个左右子链表的节点 (跟步骤二的不同,认为好理解点)

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def reorderList(self, head: Optional[ListNode]) -> None:"""Do not return anything, modify head in-place instead."""slow,fast = head,head.nextwhile fast and fast.next:slow = slow.nextfast = fast.next.next# 此时的slow在偶数个节点时实际是两个中点前一个节点,在奇数时是正确的中点mid = slow.next# 左右子链表分割slow.next = None# 反转右边pre = Nonecur = midwhile cur:temp = cur.nextcur.next = prepre = curcur = temp# 左右子链表交叉合并left_node = headright_node = pre# 哑结点dummy = ListNode(0)dummy.next=headcur = dummy# 在偶数个时,左右子链表长度相等;在奇数个时,中点是在左子链表最后的;将其交叉合并,最后剩余一个中点,加到尾部while left_node and right_node:cur.next = left_nodeleft_node = left_node.nextcur = cur.nextcur.next = right_noderight_node = right_node.nextcur = cur.nextif left_node:cur.next = left_node

步骤二

1.找中点的快慢指针初始化为head,head.next,偶数时处于靠前的中点
2.将中点后的链表作为右子链表,切断左右子链表的链接
3.反转右子链表
4.交叉合并。直接使用左子链表的头结点作为上一个步骤的哑结点,而后面也都是消耗了左右分别一个节点,所以规避掉了多余一个中点的问题。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:def reorderList(self, head: Optional[ListNode]) -> None:"""Do not return anything, modify head in-place instead."""# 特殊情况的处理if not head or not head.next:return head# 找中点slow,fast = head,head.nextwhile fast and fast.next:slow = slow.nextfast = fast.next.next# 此时的slow在偶数个节点时实际是两个中点前一个节点,在奇数时是唯一的中点(正好停在中点)# 反转右子链表pre = Nonecur = slow.next # 指针指向 偶数时靠后的中点,奇数时指向中点后的节点slow.next = None # 断开左右子链表的链接,这下从头结点只能检测到中点了,确保不会访问到右子链表while cur:temp = cur.nextcur.next = prepre = curcur = temp# 左右子链表交叉合并left_node = head # 左子链表的头节点right_node = pre # 右子链表的头节点# 在偶数个时,左右子链表长度相等;在奇数个时,中点是在左子链表最后的;将其交叉合并,最后剩余一个中点,加到尾部# 由于采用while left_node and right_node:,所以不要担心右边节点少一个的情况while left_node and right_node:# 暂存左右子链表头节点的下一个节点temp_left, temp_right = left_node.next, right_node.next# 以下两行实现交叉合并,同时始终以左子链表的节点为开始# 将左子链表的头节点指向右子链表的头节点left_node.next = right_node# 右子链表的头节点 指向 左子链表头节点的下一个节点right_node.next = temp_left# 移动左右子链表节点到下一个节点left_node, right_node = temp_left, temp_right

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/3297.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

在PostgreSQL中如何处理跨表的级联删除和更新?

文章目录 解决方案1. 使用外键约束和级联操作创建外键约束并指定级联删除创建外键约束并指定级联更新 2. 使用触发器(Triggers)创建触发器实现级联删除 示例代码示例1:使用外键约束和级联删除示例2:使用触发器实现级联删除 在Post…

Golang | Leetcode Golang题解之第44题通配符匹配

题目: 题解: func isMatch(s string, p string) bool {for len(s) > 0 && len(p) > 0 && p[len(p)-1] ! * {if charMatch(s[len(s)-1], p[len(p)-1]) {s s[:len(s)-1]p p[:len(p)-1]} else {return false}}if len(p) 0 {retur…

Python基础:【习题系列】面向对象

在Python中,用于定义类的关键字是什么?( B ) A.classs B.class C.Class D.type 答案:B 难易程度:易 答案解析:在Python中,定义类需要使用关键字class。 知识点:类定义;Python关键字 在Python中,以下哪个关键字用于在类中引用同一类的其他方法或属性?( C ) A.…

C#使用ftp进行文件上传和下载功能(二)

上一篇主要讲解FTP服务器的搭建&#xff0c;本节话不多说直接撸码&#xff1a; 1.首先ftp需要有ip和port&#xff0c;以及登录用户等信息&#xff0c;因此创建三个属性&#xff1b; /// <summary> /// FTP的服务器地址&#xff0c;格式为ftp://192.168.1.234:80…

输入influx但是无法进入influxdb

问题描述&#xff1a; 博主想通过DockerJmeterInfluxDBGrafana搭建性能测试可视化平台&#xff0c;但是按照别的教程输入influx却无法进入inluxdb&#xff0c;输入输出如下&#xff1a; NAME:influx - Influx ClientUSAGE:influx [command]HINT: If you are looking for the I…

Linux下的进程管理:创建、终止、切换与等待

文章目录 一、引言二、进程创建1、进程创建的概念与场景2、进程创建的方式a、fork() 系统调用b、fork() 后的执行流程 3、进程创建的过程a、进程创建过程b、子进程创建过程 4、父子进程关系与属性继承 三、进程终止1、进程终止的原因2、进程的错误码和退出码a、错误码b、退出码…

LeetCode:51. N 皇后

leetCode51.N皇后 题解分析 代码 class Solution { public:int n;vector<vector<string>> ans;vector<string> path;vector<bool> col, dg,udg;vector<vector<string>> solveNQueens(int _n) {n _n;col vector<bool> (n);dg …

《QT实用小工具·四十二》圆形发光图像

1、概述 源码放在文章末尾 该项目实现了图像的发光效果&#xff0c;特别适合做头像&#xff0c;项目demo演示如下所示&#xff1a; 项目部分代码如下所示&#xff1a; import QtQuick 2.7 import QtGraphicalEffects 1.12Item {id: rootwidth: 80height: 80property int ra…

浓眉大眼的Apple开源OpenELM模型;IDM-VTON试衣抱抱脸免费使用;先进的语音技术,能够轻松克隆任何人的声音

✨ 1: openelm OpenELM是苹果机器学习研究团队发布的高效开源语言模型家族 OpenELM是苹果机器学习研究团队开发的一种高效的语言模型&#xff0c;旨在推动开放研究、确保结果的可信赖性、允许对数据和模型偏见以及潜在风险进行调查。其特色在于采用了一种分层缩放策略&#x…

spring基本使用

文章目录 1. ioc(Inversion of Control) | DI(Dependency Injection)(1) maven坐标导包(2) 编写配置文件bean.xml(3) 配置bean(4) 配置文件注入属性 2. DI(dependency injection) 依赖注入(setter)其他属性(1) 对象属性注入(2) 数组属性输入(3) 集合属性注入(4) map集合注入(5)…

python将灰度图像转换为RGB图像

将灰度图像转换为RGB图像意味着你需要为每个像素创建三个颜色通道&#xff08;红、绿、蓝&#xff09;&#xff0c;通常是以某种方式复制或扩展灰度值到这三个通道。在深度学习中&#xff0c;这种转换并不常见&#xff0c;因为这样做不会引入任何新的信息到模型中。但是&#x…

如何提交已暂存的更改到本地仓库?

文章目录 如何提交已暂存的更改到本地Git仓库&#xff1f;步骤1&#xff1a;确认并暂存更改步骤2&#xff1a;提交暂存的更改到本地仓库 如何提交已暂存的更改到本地Git仓库&#xff1f; 在Git版本控制系统中&#xff0c;当你对项目文件进行修改后&#xff0c;首先需要将这些更…

使用项目管理软件有效控制项目质量

项目管理中的质量控制&#xff0c;是指团队实施策略以确保可交付成果或产品满足最终用户要求。质量控制是项目管理计划的一个要素&#xff0c;这是一个迭代过程&#xff0c;可以节省时间和资源&#xff0c;同时产生高质量的产品和服务。 质量控制的四种类型 这四种类型的质量…

TCP协议数据传输过程及报文分析

目录 TCP数据的传输过程 建立连接&#xff08;三次握手&#xff09; 第一次握手 第二次握手 第三次握手 总结 数据传输 断开连接&#xff08;四次挥手&#xff09; 第一次挥手 第二次挥手 第三次挥手 第四次挥手 总结 最后 TCP数据的传输过程 TCP&#xff08;Tra…

SL3043耐压120V降压恒压 降48V 降24V 降12V 降5V 大电流10V芯片

SL3043是一款外驱MOSFET管可设定输出电流的降压型开关稳压器&#xff0c;具有以下特点&#xff1a; 1. 宽工作电压范围&#xff1a;SL3043可以在10V至120V的宽输入电压范围内工作&#xff0c;这使得它适用于多种不同的电源环境。 2. 大输出电流&#xff1a;该芯片能够提供最大…

五年Python从业者,谈谈Python的一些优缺点

前言 Python它是作为年轻的血液&#xff0c;融入到编程语言这个大家庭里面&#xff0c;作为具有年轻人的蓬勃朝气的python&#xff0c;那它同时就会有年轻人的桀骜焦躁。 今天就来谈谈Python的一些优缺点。 先从优点说起&#xff0c;我是把它分为5部分。 1.简单————Pyth…

【Jenkins】Jenkins nohup执行失败

在使用Jenkins进行构建过程中&#xff0c;对于脚本中的nohup命令没有响应。 问题描述 当使用Jenkins调用脚本时&#xff0c;脚本中其它命令比如mv/cp等命令均可以正常执行&#xff0c;但是nohup命令没有任何响应&#xff0c;对于同样的脚本&#xff0c;在Linux本地使用root账号…

Win11和WinRAR取消折叠菜单恢复经典菜单

这里写目录标题 前言1. Win11恢复经典右键菜单1.1 修改前1.2 恢复成经典右键菜单1.3 修改后1.4 想恢复怎么办&#xff1f; 2. WinRAR取消折叠菜单恢复经典菜单2.1 修改前2.2 修改恢复为经典菜单2.3 修改后2.4 想恢复怎么办&#xff1f; 前言 最近换回了Windows电脑&#xff0c…

大模型微调之 使用 LLaMA-Factory 微调 Llama3

大模型微调之 使用 LLaMA-Factory 微调 Llama3 使用 LLaMA Factory 微调 Llama-3 中文对话模型 安装 LLaMA Factory 依赖 %cd /content/ %rm -rf LLaMA-Factory !git clone https://github.com/hiyouga/LLaMA-Factory.git %cd LLaMA-Factory %ls !pip install "unsloth…

在Spring Boot应用中实现阿里云短信功能的整合

1.程序员必备程序网站 天梦星服务平台 (tmxkj.top)https://tmxkj.top/#/ 2.导入坐标 <dependency><groupId>com.aliyun</groupId><artifactId>aliyun-java-sdk-core</artifactId><version>4.5.0</version></dependency><…