【NOWCODE FIVE】:链表

最新推荐文章于 2022-09-30 23:44:29 发布

今日说"法"

最新推荐文章于 2022-09-30 23:44:29 发布

阅读量259

点赞数

分类专栏： NOWCODE系列

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

版权

NOWCODE系列专栏收录该内容

8 篇文章 0 订阅

订阅专栏

🤵Author：今日说“法”

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

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

⚡️前言

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

工具介绍：链表

定义

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

结构

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

优缺点

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

CODE Exercise：

One:单链表的排序

难度：⭐⭐⭐ ⭐

时间限制：1秒

空间限制：256M

描述

给定一个节点数为n的无序单链表，对其按升序排序。

数据范围：0<n≤100000

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

示例1

输入：[1,3,2,4,5]

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

示例2

输入：[-1,0,-2]

返回值：{-2,-1,0}

Submit(python)


class Solution:
    def sortInList(self , head: ListNode) -> ListNode:
        # write code here
        N=[]
        while head is not None:
            N.append(head.val)
            head=head.next
        N.sort()
        pre=N1=ListNode(-1)
        for _ in range(len(N)):
            p=ListNode(N[_])
            N1.next=p
            N1=N1.next
        return pre.next

Two: 判断一个链表是否为回文结构

难度：⭐⭐⭐ ⭐

时间限制：1秒

空间限制：256M

描述

给定一个链表，请判断该链表是否为回文结构。

回文是指该字符串正序逆序完全一致。

数据范围：链表节点数0≤n≤105，链表中每个节点的值满足 ∣val∣≤107

示例1

输入：{1}

返回值：true

示例2

输入：{2,1}

返回值：false

说明：2->1

示例3

输入：{1,2,2,1}

返回值：true

说明：1->2->2->1

Submit(python)


class Solution:
    def isPail(self , head: ListNode) -> bool:
        # write code here
        N=[]
        while head is not None:
            N.append(head.val)
            head=head.next
        N1=[]
        for _ in range(len(N)-1,-1,-1):
            N1.append(N[_])
        
        for _ in range(len(N)):
            #print(N1[_],N[_])
            if N1[_]!=N[_]:
                return False
        return True

Three: 链表的奇偶重排

难度：⭐⭐⭐ ⭐

时间限制：1秒

空间限制：256M

描述

给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。

注意是节点的编号而非节点的数值。

数据范围：节点数量满足0≤n≤105，节点中的值都满足0≤val≤1000

要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1

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

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

说明：1->2->3->4->5->6->NULL

重排后为1->3->5->2->4->6->NULL

示例2

输入：{1,4,6,3,7}

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

说明：1->4->6->3->7->NULL重排后为1->6->7->4->3->NULL
奇数位节点有1,6,7，偶数位节点有4,3。重排后为1,6,7,4,3

备注：
链表长度不大于200000。每个数范围均在int内。

Submit(python)


class Solution:
    def oddEvenList(self , head: ListNode) -> ListNode:
        # write code here
        """
        #转化成两个数组，分别储存奇数位，和偶数位
        N1=[]
        N2=[]
        pre=head
        count=1
        while pre is not None:
            if count %2==0:
                N2.append(pre.val)
            if count %2==1:
                N1.append(pre.val)
            pre=pre.next
            count+=1
        temp=N=ListNode(-1)
        for _ in range(len(N1)):
            N.next=ListNode(N1[_])
            N=N.next
        for _ in range(len(N2)):
            N.next=ListNode(N2[_])
            N=N.next
        return temp.next
        """
        #链表拆接
        if not head:
            return head
        pre=head
        N=head.next
        cur=N
        while cur is not None and cur.next is not None :
            pre.next=cur.next
            pre=pre.next
            cur.next=pre.next
            cur=cur.next
        pre.next=N
        return head