day2-Datawhale-数据结构与算法

理论部分

理解线性表的定义与操作。
实现顺序表。
实现单链表、循环链表、双向链表。

练习部分

1. 合并两个有序链表

https://leetcode-cn.com/problems/merge-two-sorted-lists/

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

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

代码：

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = ListNode(0)
        prev = res   #prev和res同时指向一个链表，prev移动进行链表操作。
        while l1 is not None and l2 is not None:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next
            prev = prev.next
        prev.next = l1 if l1 is not None else l2
        return res.next  # res一直指向结果链表的首结点，所以prev完成移动后，结果链表即形成

结果：

2. 删除链表的倒数第N个节点

https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

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

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

代码：

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = ListNode(0)
        prev = res   #prev和res同时指向一个链表，prev移动进行链表操作。
        while l1 is not None and l2 is not None:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next
            prev = prev.next
        prev.next = l1 if l1 is not None else l2
        return res.next  # res一直指向结果链表的首结点，所以prev完成移动后，结果链表即形成

结果：

3. 旋转链表

https://leetcode-cn.com/problems/rotate-list/

给定一个链表，旋转链表，将链表每个节点向右移动k个位置，其中k是非负数。

示例 1:

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

解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

示例 2:

输入: 0->1->2->NULL, k = 4
输出: 2->0->1->NULL

解释:
向右旋转 1 步: 2->0->1->NULL
向右旋转 2 步: 1->2->0->NULL
向右旋转 3 步: 0->1->2->NULL
向右旋转 4 步: 2->0->1->NULL

代码：

class Solution:
    def rotateRight(self, head: ListNode, k: int) -> ListNode:
        len = 0
        res,l1,l2 = head,head,head
        while l1 is not None:  #获取链表长度
            l1 = l1.next
            len+=1
        if k > len:     #实现循环移动
            k= k%len
        for i in range(1,len-k):
            l2 = l2.next
        res = l2.next
        l2.next = None
        res1 = res
        for j in range(k-1):
            res1 = res1.next
        res1.next = head
        return res

结果：