leetcode 刷题视频(1) - 链表

最新推荐文章于 2022-03-11 15:47:50 发布

两个幽灵

最新推荐文章于 2022-03-11 15:47:50 发布

阅读量278

点赞数 1

分类专栏：算法

原文链接：https://www.bilibili.com/video/BV1GW411Q77S

版权

算法专栏收录该内容

20 篇文章 1 订阅

订阅专栏

链表

问题1 链表逆序

1-a 基本问题

Reverse a singly linked list.

Example:

Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

在这里插入图片描述

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* new_head = NULL;
        while (head) {
            ListNode* next = head->next;
            head->next = new_head;
            new_head = head;
            head = next;
        }
        return new_head;
    }
};

1-b 逆序一部分

Reverse a linked list from position m to n. Do it in one-pass.

Note: 1 ≤ m ≤ n ≤ length of list.

Example:

Input: 1->2->3->4->5->NULL, m = 2, n = 4
Output: 1->4->3->2->5->NULL

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

在这里插入图片描述

问题2 链表交点

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

begin to intersect at node c1.

Example 1:

Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
Output: Reference of the node with value = 8
Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.

Example 2:

Input: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
Output: Reference of the node with value = 2
Input Explanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect). From the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.

Example 3:

Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
Output: null
Input Explanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.
Explanation: The two lists do not intersect, so return null.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Each value on each linked list is in the range [1, 10^9].
Your code should preferably run in O(n) time and use only O(1) memory.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2-a 思路1

在这里插入图片描述

复杂度比较高。时间复杂度 $O(n\log n)$ ，空间复杂度 $O (n)$ ，主要是因为set结构。

2-b 思路2

在这里插入图片描述

问题3 链表求环

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail’s next pointer is connected to. Note that pos is not passed as a parameter.

Notice that you should not modify the linked list.

Follow up:

Can you solve it using O(1) (i.e. constant) memory?

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: tail connects to node index 1
Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2:

Input: head = [1,2], pos = 0
Output: tail connects to node index 0
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

Input: head = [1], pos = -1
Output: no cycle
Explanation: There is no cycle in the linked list.

Constraints:

The number of the nodes in the list is in the range [0, 104].
-105 <= Node.val <= 105
pos is -1 or a valid index in the linked-list.

链接：https://leetcode-cn.com/problems/linked-list-cycle-ii/

2-a 思路1

在这里插入图片描述

2-b 思路2 快慢指针赛跑

在这里插入图片描述

上面的相遇点不在环的起始点

在这里插入图片描述

问1：为什么相遇时一个路程是另一个的两倍？答：因为速度是两倍关系。

问2：为什么从head和meet出发，相遇时是环的起点？答：因为快的多走了一倍的路程，多出来的一倍路程在蓝色区域是重叠的，所以绿色与黄色必须相等，才能保证两倍关系成立。

起点竟然是直接从1开始而不是从1前面开始。好像是无论在1前面加多少个节点都不影响结果。
——2021年1月2日21:13:45

问题4 链表划分

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.

Example:

Input: head = 1->4->3->2->5->2, x = 3
Output: 1->2->2->4->3->5

链接：https://leetcode-cn.com/problems/partition-list/

在这里插入图片描述

问题5 复杂链表的深拷贝

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:

val: an integer representing Node.val
random_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.

Example 1:

Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]

Example 2:

Input: head = [[1,1],[2,1]]
Output: [[1,1],[2,1]]

Example 3:

Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]

Example 4:

Input: head = []
Output: []
Explanation: Given linked list is empty (null pointer), so return null.

Constraints:

-10000 <= Node.val <= 10000
Node.random is null or pointing to a node in the linked list.
Number of Nodes will not exceed 1000.

链接：https://leetcode-cn.com/problems/copy-list-with-random-pointer/

要拷贝next还要拷贝random的关系。

在这里插入图片描述

原链表节点地址与 index 的映射；index 与新链表节点地址的映射

问题6 链表的归并排序

6-a 合并两个链表

Merge two sorted linked lists and return it as a new sorted list. The new list should be made by splicing together the nodes of the first two lists.

Example 1:

Input: l1 = [1,2,4], l2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:

Input: l1 = [], l2 = []
Output: []

Example 3:

Input: l1 = [], l2 = [0]
Output: [0]

Constraints:

The number of nodes in both lists is in the range [0, 50].
-100 <= Node.val <= 100
Both l1 and l2 are sorted in non-decreasing order.

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

在这里插入图片描述

6-b 合并k个链表

You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Example 1:

Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
  1->4->5,
  1->3->4,
  2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6

Example 2:

Input: lists = []
Output: []

Example 3:

Input: lists = [[]]
Output: []

Constraints:

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] is sorted in ascending order.
The sum of lists[i].length won’t exceed 10^4.

链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/

在这里插入图片描述

方法一是将所有链表的所有元素添加到一个链表中，然后对整个链表排序，复杂度是 $O(kn\log kn)$ ，k是链表个数，n是单个链表长度

方法二是先合并1 2命名为a，然后a与3合并，命名为b，然后b与4合并，命名为c……

好像方法2的复杂度是 $O(k^2n)$ 。写成 $kn\cdot k$ ，与方法1相比( $kn\cdot\log kn$ )，当列表变的很长而 $k$ 比较小时，方法1的复杂度明显更高。

关于面试准备

在不看回放与复习的前提下，重新做题提交测试
尽量多的通过这些题目
在纸上写代码反复练习
将leetcode其它链表相关题目完成

两个幽灵

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode 刷题视频(1) - 链表

链表问题1 链表逆序1-a 基本问题Reverse a singly linked list.Example:Input: 1->2->3->4->5->NULLOutput: 5->4->3->2->1->NULL来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reverse-linked-list著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。c
复制链接

扫一扫