算法通关村第一关——链表经典问题之双指针笔记

清眉冷

已于 2023-11-17 09:34:13 修改

阅读量81

点赞数

文章标签：算法链表笔记

于 2023-10-26 16:44:23 首次发布

本文链接：https://blog.csdn.net/weixin_52397263/article/details/134059760

版权

双指针专题

1 寻找中间结点

LeetCode876 ：给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

示例1
输入：[1,2,3,4,5]
输出：此列表中的结点 3
示例2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4

快慢指针：用两个指针 slow 与 fast 一起遍历链表。slow 一次走一步，fast 一次走两步。那么当 fast 到达链表的末尾时，slow 必然位于中间。

public ListNode middleNode(ListNode head) {
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next; //只要fast.next!= null，但fast.next.next可以为空
    }
    return slow;
}

‍

2寻找倒数第K个元素

要求：

输入一个链表，输出该链表中倒数第k个节点。本题从1开始计数，即链表的尾节点是倒数第1个节点。
示例
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.

可以使用快慢双指针

我们先将fast 向后遍历到第 k+1 个节点， slow仍然指向链表的第一个节点，此时指针fast 与slow 二者之间刚好间隔 k 个节点。
- 之后两个指针同步向后走，当 fast 走到链表的尾部空节点时，slow 指针刚好指向链表的倒数第k个节点。
关键：注意链表的长度可能小于k，寻找k位置的时候必须判断fast是否为null。

在这里插入图片描述


public ListNode getKthFromEnd(ListNode head, int k) {
    ListNode fast = head;
    ListNode slow = head;
    while (fast != null && k > 0) {
        fast = fast.next;
        k--;
    }
    while (fast != null) {
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
}

3 旋转链表

Leetcode61：给定一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例1:
输入：head = [1,2,3,4,5], k = 2

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

‍

思路：先用双指针策略找到倒数K的位置，即{1,2,3}和{4,5}两个序列，之后再将两个链表拼接成{4,5,1,2,3}就行了。
1.快指针先走k步。

2.慢指针和快指针一起走。

3.快指针走到链表尾部时，慢指针所在位置刚好是要断开的地方。
把快指针指向的节点连到原链表头部，慢指针指向的节点断开和下一节点的联系。

4.返回结束时慢指针指向节点的下一节点。

public ListNode rotateRight(ListNode head, int k) {
    if(head == null || k == 0){
        return head;
    }
    ListNode temp = head;
    ListNode fast = head;
    ListNode slow = head;
    int len = 0;
    while(head != null){
        head = head.next;
        len++;
    }
    if(k % len == 0){// = 0，则不用旋转，直接返回头结点
        return temp;
    }    //取模，防止k大于len的情况
  
    while((k % len) > 0){
        k--; //fast 从头结点开始向后走向后遍历到第 k+1 个结点
        fast = fast.next;
    }
    // 快指针走了k步了，然后快慢指针一起向后执行
    while(fast.next != null){
        fast = fast.next;//直到fast到尾结点。fast.next == null
        slow = slow.next; // slow就在倒数第K个的前一个位置上，刚好是要断开的地方。
    }
    ListNode res = slow.next;//res = 新的前一半段的头结点
    slow.next = null; // 慢指针指向的节点断开和下一节点的联系
    fast.next = temp;//快指针走到链表尾部时，快指针指向的节点连到原链表头部
    return res; //返回结束时慢指针指向节点的下一节点。
}

在这里插入图片描述

‍

公共子节点双指针法

先看下面的链表A和B：
A: 0-1-2-3-4-5
B: a-b-4-5
如果分别拼接成AB和BA会怎么样呢？
AB：0-1-2-3-4-5-a-b-4-5
BA：a-b-4-5-0-1-2-3-4-5
我们发现拼接后从最后的4开始，两个链表是一样的了，自然4就是要找的节点，所以可以通过拼接的方式来寻找交点。

理由：假定A和B有相交的位置，以交点为中心，可以将两个链表分别分为left_a和right_a，left_b和right_b这样四个部分，并且right_a和right_b是一样的，拼接AB和BA就是这样的结构：

在这里插入图片描述

right_a和right_b是一样的，如果分别遍历AB和BA就从某个位置开始恰好就找到了相交的点了。

双指针法

Leetcode160. 相交链表：

当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；

同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。

这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。

如果不存在交点， l1 + l2 = l2 + l1，以下代码中 p1 和 p2 会同时为 null，从而退出循环。

public ListNode findFirstCommonNode(ListNode pHead1, ListNode pHead2) {
    if(pHead1==null || pHead2==null){ // 边界判断
        return null;
    }

    ListNode p1=pHead1, ListNode p2=pHead2;
    //指针 P1 和 指针 P2 不断向后遍历，直到找到相交点

    while(p1!=p2){
		 // 指针 P1 一开始在链表 1 上遍历，当走到链表 1 的尾部即 null 时，跳转到链表 2上 
         p1 = p1 == null ? pHead2 : p1.next;
         // 指针 P2 一开始在链表2 上遍历，当走到链表 2 的尾部即 null 时，跳转到链表 1 上 
         p2 = p2 == null ? pHead1 : p2.next;
        }
    return p1;
}