leetcode-链表专题

25.K个一组翻转链表

题目链接

25. K 个一组翻转链表 - 力扣(LeetCode)

解题思路

复制代码
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        n = 0
        cur = head
        while cur:
            n += 1#统计节点个数
            cur = cur.next
        p0 = dummy = ListNode(next = head)
        pre = None
        cur = head
        while n >= k:
            n -= k
            for _ in range(k):
                nxt = cur.next
                cur.next = pre
                pre = cur
                cur = nxt
            
            nxt = p0.next
            nxt.next = cur
            p0.next = pre
            p0 = nxt
        return dummy.next

138.随机链表的复制

题目链接

148. 排序链表 - 力扣(LeetCode)

解题思路

复制代码
# 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]:
        length = 0
        if head == None or head.next == None: return head
        currentNode = head
        values = []
        while currentNode:
            length += 1
            values.append(currentNode.val)
            currentNode = currentNode.next
        values =sorted( values )
        currentNode = head
        i = 0
        while currentNode:
            currentNode.val = values[i]     
            currentNode = currentNode.next
            i += 1
        return head

146.LRU缓存

题目链接

146. LRU 缓存 - 力扣(LeetCode)

解题思路

复制代码
class ListNode:
    def __init__(self, key=None, value=None):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None


class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.hashmap = {}
        # 新建两个节点 head 和 tail
        self.head = ListNode()
        self.tail = ListNode()
        # 初始化链表为 head <-> tail
        self.head.next = self.tail
        self.tail.prev = self.head

    # 因为get与put操作都可能需要将双向链表中的某个节点移到末尾,所以定义一个方法
    def move_node_to_tail(self, key):
            # 先将哈希表key指向的节点拎出来,为了简洁起名node
            #      hashmap[key]                               hashmap[key]
            #           |                                          |
            #           V              -->                         V
            # prev <-> node <-> next         pre <-> next   ...   node
            node = self.hashmap[key]
            node.prev.next = node.next
            node.next.prev = node.prev
            # 之后将node插入到尾节点前
            #                 hashmap[key]                 hashmap[key]
            #                      |                            |
            #                      V        -->                 V
            # prev <-> tail  ...  node                prev <-> node <-> tail
            node.prev = self.tail.prev
            node.next = self.tail
            self.tail.prev.next = node
            self.tail.prev = node

    def get(self, key: int) -> int:
        if key in self.hashmap:
            # 如果已经在链表中了久把它移到末尾(变成最新访问的)
            self.move_node_to_tail(key)
        res = self.hashmap.get(key, -1)
        if res == -1:
            return res
        else:
            return res.value

    def put(self, key: int, value: int) -> None:
        if key in self.hashmap:
            # 如果key本身已经在哈希表中了就不需要在链表中加入新的节点
            # 但是需要更新字典该值对应节点的value
            self.hashmap[key].value = value
            # 之后将该节点移到末尾
            self.move_node_to_tail(key)
        else:
            if len(self.hashmap) == self.capacity:
                # 去掉哈希表对应项
                self.hashmap.pop(self.head.next.key)
                # 去掉最久没有被访问过的节点,即头节点之后的节点
                self.head.next = self.head.next.next
                self.head.next.prev = self.head
            # 如果不在的话就插入到尾节点前
            new = ListNode(key, value)
            self.hashmap[key] = new
            new.prev = self.tail.prev
            new.next = self.tail
            self.tail.prev.next = new
            self.tail.prev = new
相关推荐
Sun_light17 分钟前
队列:先进先出的线性数据结构及其应用
前端·javascript·算法
吕小鸣44 分钟前
Coze、Dify、FastGPT三大AI智能平台架构与能力对比
算法
jndingxin1 小时前
c++ 面试题(1)-----深度优先搜索(DFS)实现
c++·算法·深度优先
北极的树1 小时前
谁说AI只会模仿,从Google AlphaEvolve项目看算法的自主创新
人工智能·算法·gemini
Watink Cpper1 小时前
[灵感源于算法] 算法问题的优雅解法
linux·开发语言·数据结构·c++·算法·leetcode
随意0231 小时前
STL 3算法
开发语言·c++·算法
_风满楼2 小时前
如何优雅展示日历中的重叠日程?三步搞定复杂布局
前端·javascript·算法
এ᭄画画的北北3 小时前
力扣-35.搜索插入位置
数据结构·算法·leetcode
cylat3 小时前
Day23 pipeline管道
人工智能·python·算法·机器学习
lucky_jiexia4 小时前
leetcode刷题经验
算法·leetcode·哈希算法