前言
-
现在前端要求变高了,找工作的时可能会碰上算法题,每天刷几道算法题做足准备,今天是《剑指 Offer（专项突击版）》第23|24题。
剑指 Offer II 023. 两个链表的第一个重合节点
给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
难度：简单
图示两个链表在节点 c1 开始相交 ：
 [1]
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
 [2]
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
 [3]
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。 在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
 [4]
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。 由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 这两个链表不相交，因此返回 null 。
知识点： 哈希表[5] 链表[6] 双指针[7]
方法一：双指针
只有当链表 headA 和 headB 都不为空时，两个链表才可能相交。因此首先判断链表 headA 和 headB 是否为空，如果其中至少有一个链表为空，则两个链表一定不相交，返回 null。
当链表 headA 和 headB 都不为空时，创建两个指针 pA 和 pB，初始时分别指向两个链表的头节点 headA 和 headB，然后将两个指针依次遍历两个链表的每个节点。
具体做法如下：
每步操作需要同时更新指针 pA 和 pB。
如果指针 pA 不为空，则将指针 pA 移到下一个节点；如果指针 pB 不为空，则将指针 pB 移到下一个节点。
如果指针 pA 为空，则将指针 pA 移到链表 headB 的头节点；如果指针 pB 为空，则将指针 pB 移到链表 headA 的头节点。
当指针 pA 和 pB 指向同一个节点或者都为空时，返回它们指向的节点或者 null。
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
* @param {ListNode} headA
* @param {ListNode} headB
* @return {ListNode}
*/
var getIntersectionNode = function(headA, headB) {
if (headA === null || headB === null) return null;
let pA = headA, pB = headB;
while (pA !== pB) {
pA = pA === null ? headB : pA.next;
pB = pB === null ? headA : pB.next;
}
return pA;
};
复杂度分析
-
时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。
-
空间复杂度：O(1)。
剑指 Offer II 024. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
难度：简单
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
方法一：迭代法
链表与数组的不同在于没有索引，不能通过下标获取当前值，所以需要一个节点一个节点进行反转。
在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存
储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
关键步骤：
-
存储原本的next节点
-
将当前next指向前一个节点
-
将前一个节点指向当前节点
-
将当前节点指向存储的next节点
(如果有点饶，可以画图，多想多记)
* Definition for singly-linked list.
* function ListNode(val, next) {
* this.val = (val===undefined ? 0 : val)
* this.next = (next===undefined ? null : next)
* }
*/
* @param {ListNode} head
* @return {ListNode}
*/
var reverseList = function(head) {
let preHead = null;
let cur = head;
while (cur !== null) {
let next = cur.next;
cur.next = preHead;
preHead = cur;
cur = next;
}
return preHead;
};
复杂度分析
-
时间复杂度：O(n)，其中 n** 是链表的长度。需要遍历链表一次。
-
空间复杂度：O(1)。
方法二：头插法
思路：准备一个临时节点，然后遍历链表，准备两个指针head和next，每次循环到一个节点的时候，将
head.next指向temp.next，并且将temp.next指向head，head和next向后移一位。
var reverseList = function (head) {
let temp = new ListNode();
let next = null;
while (head) {
next = head.next;
head.next = temp.next;
temp.next = head;
head = next;
}
return temp.next;
};
复杂度分析：
-
时间复杂度：O(n)， n为链表节点数
-
空间复杂度：O(1)
方法三：递归
var reverseList = function(head) {
if (head == null || head.next == null) {
return head;
}
const newHead = reverseList(head.next);
head.next.next = head;
head.next = null;
return newHead;
};
复杂度分析
-
时间复杂度：O(n)，假设 n 是列表的长度，那么时间复杂度为 O(n)。
-
空间复杂度：O(n)，由于使用递归，将会使用隐式栈空间。递归深度可能会达到 n 层。
so
-
结尾依旧：长风破浪会有时，直挂云帆济沧海！
-
在线整理的确实很好，对文章进行了一个汇总整理，在线备战面试、刷题指南，拿走不谢，要学会站在别人的肩膀上提升自己点击这里-->
最后:
如果你现在正在找工作，可以私信“web”或者直接添加小助理进群领取前端面试小册、简历优化修改、大厂内推以及更多阿里、字节大厂面试真题合集，和p8大佬一起交流。