[S]O-22/23/24 链表倒数第k个节点、反转链表、合并排序列表（Python）

最新推荐文章于 2021-06-20 14:19:09 发布

哞哞哞是Echo

最新推荐文章于 2021-06-20 14:19:09 发布

阅读量143

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/echooozhang/article/details/112431042

版权

leetcode 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

[S]O-22/23/24 链表倒数第k个节点、反转链表、合并排序列表（Python）

1. O-22链表倒数第k个节点-题目描述：

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

1.分析与代码

普通思路即为：
先遍历统计链表长度，记为 n ；
设置一个指针走 (n-k)步，即可找到链表倒数第 k个节点。
见代码注释的普通方法部分。

使用双指针则可以不用统计链表长度。

初始化：前指针faster 、后指针slow ，双指针都指向头节点 head 。
构建双指针距离： 前指针 faster 先向前走 k 步（结束后，双指针间相距 k 步）。
双指针共同移动： 循环中，双指针faster和 slow 每轮都向前走一步，直至 faster走过链表尾节点时跳出（跳出后， slow 与尾节点距离为 k-1，即 slow指向倒数第 kk 个节点）。
返回值：返回 slow即可。

参考：link

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
    #普通方法
        # n=0
        # cur=head
        # while(cur):
        #     n+=1
        #     cur=cur.next
        # for _ in range(n-k):
        #     head=head.next
        # return head
       
        #method
        fast,slow=head,head
        for _ in range(k):
            if not fast:return
            fast=fast.next
        while(fast):
            fast,slow=fast.next,slow.next
        return slow

2. 0-23反转链表-题目描述：

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

2.分析与代码

考虑遍历链表，并在访问各节点时修改 next 引用指向，算法流程见注释。
在这里插入图片描述

复杂度分析：
时间复杂度 O(N)：遍历链表使用线性大小时间。
空间复杂度 O(1)：变量 pre 和 cur 使用常数大小额外空间

参考链接

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        #双指针
        pre,cur=None,head
        while(cur):
            temp=cur.next
            cur.next=pre
            pre,cur=cur,temp
        return pre

3. O-24合并排序列表-题目描述：

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

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

3.分析与代码

根据题目描述，链表 L1L2 是递增的，因此容易想到使用双指针,遍历两链表，根据L1.val 和 L2.vall 的大小关系确定节点添加顺序，两节点指针交替前进，直至遍历完毕。

引入伪头节点：由于初始状态合并链表中无节点，因此循环第一轮时无法将节点添加到合并链表中。
解决方案：初始化一个辅助节点作为合并链表的伪头节点，将各节点添加至之后。
在这里插入图片描述

初始化：伪头节点head_new ，节点 cur指向head_new 。
循环合并：当 L1或L2为空时跳出；
当 L1.val < L2.val时： cur的后继节点指定为 L1 ，并 L1向前走一步
L1.val≥L2 .val 时： cur 的后继节点指定为 L2,并 L2向前走一步
节点 cur向前走一步，即 cur = cur.next。
合并剩余尾部：跳出时有两种情况，即L1为空或 L2为空。
若 L1 =null ：将 L1添加至节点 cur之后；
否则：将 L2 添加至节点 cur 之后。
返回值：合并链表在伪头节点head_new 之后，因此返回 head_new.next 即可

参考链接

Python 三元表达式写法 A if x else B ，代表当 x = Truex=True 时执行 A ，否则执行B

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        head_new=ListNode(0)
        cur=head_new
        while(l1 and l2):
            if(l1.val<l2.val):
                cur.next,l1=l1,l1.next
            else:
                cur.next,l2=l2,l2.next
            cur=cur.next
        cur.next=l1 if l1 else l2
        return head_new.next