【NOWCODE TWO】:链表

最新推荐文章于 2023-09-06 15:39:28 发布

今日说"法"

最新推荐文章于 2023-09-06 15:39:28 发布

阅读量115

点赞数

分类专栏： NOWCODE系列文章标签： java 服务器 servlet

本文链接：https://blog.csdn.net/m0_56902859/article/details/127071916

版权

NOWCODE系列专栏收录该内容

8 篇文章 0 订阅

订阅专栏

🤵Author：今日说“法”

🏆主攻领域：算法分析与设计

📰个人主页：今日说"法"的博客
📝系列专栏：NOWCODE系列

⚡️前言

一位大佬曾经说过：程序=数据结构+算法 ，数据结构相当于一套普遍适用的工具，算法相当于一套行之有效的解题方法和解题步骤。Dambisa Moyo 曾经说过：“种一颗树最好的时间是十年前，其次是现在。”所以十年前没有刷题的朋友，现在跟着博主一起刷题吧。

工具介绍：链表

定义

链表通常由一连串节点（“链结点”）组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（“links”）。
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

结构

链表结点=数据+地址（下一个结点的地址）

优缺点

与数组相比：
　　使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
　　链表是一种插入和删除都比较快的数据结构，缺点是查找比较慢。除非需要频繁的通过下标来随机访问数据，否则在很多使用数组的地方都可以用链表代替。

CODE Exercise：

ONE 链表中的节点每K个一组翻转

难度指数：⭐⭐⭐⭐

时间限制：1秒

空间限制：256M

描述

将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。

数据范围： 0≤n≤2000 ， 1≤k≤2000 ，链表中每个元素都满足 10000≤val≤1000
要求空间复杂度 O(1)，时间复杂度 O(n)

例如：

给定的链表是 1→2→3→4→5

对于 k = 2 , 你应该返回2→1→4→3→5

对于 k = 3 , 你应该返回 3→2→1→4→5

示例1

输入：{1,2,3,4,5},2

返回值：{2,1,4,3,5}

示例2

输入：{},1

返回值：{}

Submit(python) :


class Solution:
    def reverseKGroup(self , head: ListNode, k: int) -> ListNode:
        Test=ListNode(-1) #定义哨兵节点，老套路了
        Test.next=head
        lend=Test.next
        i=0
        while lend:
            i=i+1 #求链表总长度
            lend=lend.next 
        print(i)
        pre = Test
        cur = pre.next
        while head and i>=k:  #分组进行判断，一组组进行反转
            for j in range(k-1):      #当前这组满足反转的
                next = cur.next
                cur.next = next.next
                next.next = pre.next
                pre.next = next
            i = i-k               #分组的思想，减去已经反转的个数，供下一次循环得到条件
            pre = cur               
            cur = pre.next
        return Test.next

TWO 合并两个排序的链表

难度指数：⭐⭐⭐

时间限制：1秒

空间限制：256M

描述

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0≤n≤1000，−1000≤节点值≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}，转换过程如下图所示：

或输入{-1,2,4},{1,3,4}时，合并后的链表为{-1,1,2,3,4,4}，所以对应的输出为{-1,1,2,3,4,4}，转换过程如下图所示：

示例1

输入：{1,3,5},{2,4,6}

返回值：{1,2,3,4,5,6}

示例2

输入：{},{}

返回值：{}

示例3

输入：{-1,2,4},{1,3,4}

返回值：{-1,1,2,3,4,4}

Submit(python) :

class Solution:
    def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
        #一个已经为空了，直接返回另一个
        if pHead1 == None: 
            return pHead2
        if pHead2 == None:
            return pHead1
        #加一个表头
        head = ListNode(0) 
        cur = head
        #两个链表都要不为空
        while pHead1 and pHead2: 
            #取较小值的节点
            if pHead1.val <= pHead2.val: 
                cur.next = pHead1
                #只移动取值的指针
                pHead1 = pHead1.next 
            else:
                cur.next = pHead2
                #只移动取值的指针
                pHead2 = pHead2.next 
            #指针后移
            cur = cur.next 
        #哪个链表还有剩，直接连在后面
        if pHead1: 
            cur.next = pHead1
        else:
            cur.next = pHead2
        #返回值去掉表头
        return head.next

Three 合并K个已排序的链表

难度指数：⭐⭐⭐⭐⭐

时间限制：1秒

空间限制：256M

描述

合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数0≤n≤5000，每个节点的val满足 ∣val∣<=1000

要求：时间复杂度 O(nlogn)

示例1

输入：[{1,2,3},{4,5,6,7}]

返回值：{1,2,3,4,5,6,7}

示例2

输入：[{1,2},{1,4,5},{6}]

返回值：{1,1,2,4,5,6}

Submit(python) :


class Solution:
    def mergeKLists(self , lists: List[ListNode]) -> ListNode:
        # write code here
        if lists is None: return None
        result = []
        for pHead in lists:
            while pHead:
                result.append(pHead.val)
                pHead = pHead.next
        if len(result) == 0: return None
        result.sort()
        head1 = NewHead = ListNode(0)
        for data in result:
            NewHead.next = ListNode(0)
            NewHead = NewHead.next
            NewHead.val = data
            
        return head1.next