0
点赞
收藏
分享

微信扫一扫

链表双指针

四月天2021 2022-03-30 阅读 59
c++算法

文章目录

21 合并两个有序双链表

题目

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

img

示例 1:

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

示例 2:

输入:l1 = [], l2 = []
输出:[]

示例 3:

输入:l1 = [], l2 = [0]
输出:[0]

提示:

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

问题分析

双指针

两个链表都是有序的,因此,利用双指针,分别指向两个链表,比较大小,再定义一个指针,用来返回结果

image-20220328222633004 image-20220328222940611

下面直接通过代码来方便理解

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        // 特殊处理
        if (list1 == nullptr) return list1;
        if (list2 == nullptr) return list2;
        // 结果指针
        ListNode* ans = new ListNode(0);
        // 遍历指针
        ListNode* p = ans;
        while (list1 != nullptr && list2 != nullptr) {
            // 比较规则
            if (list1->val < list2->val) {
                p->next = list1; // 指针指向数值小的
                list1 = list1->next; // 该链表下移
            } else {
                p->next = list2; // 否则指针指向数值大的
                list2 = list2->next; // 该链表下移
            }
            p = p->next; // 结果指针下移
        }
        // 当一个链表结束后,结果指针直接指向另一个链表
        if (list1 != nullptr) {
            p->next = list1;
        }
        if (list2 != nullptr) {
            p->next = list2;
        }
        // 结果指针定义的时候有头结点,因此返回头结点下一个地址
        return ans->next;
    }
};
递归

从上面的问题分析中可以知道,每次比较的问题基本类似,具有重叠子问题的结构,因此,本题也可以利用递归去求解。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) return list2;
        else if (list2 == null) return list1;
        // 比较规则
        else if (list1.val < list2.val) {
            // 递归, 递归的参数是l1的下一个地址,即已经排好序了一个元素,
            // 将剩下的元素继续和l2进行比较
            list1.next = mergeTwoLists(list1.next, list2);
            // 确定了第一个元素在l1中,则返回l1
            return list1;
        } else {
            // 同上
            list2.next = mergeTwoLists(list1, list2.next);
            // 确定了第一个元素在l2中,则返回l2
            return list2;
        }
    }
}

83 删除排序链表中的重复元素

给定一个已排序的链表的头 head , 删除所有重复的元素,使每个元素只出现一次 。返回 已排序的链表 。

示例 1:

img

输入:head = [1,1,2]
输出:[1,2]
示例 2:

img

输入:head = [1,1,2,3,3]
输出:[1,2,3]

提示:

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列

问题分析

删除重复元素,最简单地方式就是利用定义两个指针,一前一后,如果两个指针指向的值相等,则让后指针的next指向前指针的下一个结点,然后再进行比较,如果还想等,就在前移,直到为null

image-20220329001625961 image-20220329001845789
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        // 空链表直接返回
        if (head == nullptr) return head;
        ListNode* cur = head;
        // 循环条件为遍历指针的next指针不为空
        while (cur->next != nullptr) {
            // 当前指针指向的值和下一个结点的值进行比较
            if (cur->val == cur->next->val) {
                // 相同就跳过下一个结点,指向下下个结点
                cur->next = cur->next->next;
            } else {
                // 不相同就令遍历指针下移
                cur = cur->next;
            }
        }
        // 返回头结点
        return head;
    }
};
递归

仔细观察,可以看出来,算法的核心步骤就是在进行两个结点之间的比较,所以具有重复子问题的结构

因此,可以用递归来求解

image-20220329003139029

图中黄色箭头指向的链表就是最后的结果

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        // 链表为空就返回
        if (head == null || head.next == null) return head;
        // 调用递归
        head.next = deleteDuplicates(head.next);
        // 比较当前结点和下一个结点的值,相等就跳过,返回下下个结点
        return head.val == head.next.val ? head.next : head;
    }
}

141. 环形链表

题目

给你一个链表的头节点 head ,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ,则返回 true 。 否则,返回 false 。

示例 1:

img

输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。

示例 2:

img

输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。

示例 3:

img

输入:head = [1], pos = -1
输出:false
解释:链表中没有环。

提示:

链表中节点的数目范围是 [0, 104]
− 1 0 5 < = N o d e . v a l < = 1 0 5 -10^5 <= Node.val <= 10^5 105<=Node.val<=105
pos 为 -1 或者链表中的一个 有效索引 。

问题分析

这道题就是判断链表是否形成了环

利用Floyd算法,建立快慢双指针就可以轻松解决问题了

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // Floyd 算法 快慢双指针

    public boolean hasCycle(ListNode head) {
        if (head == null) return false;
        // 定义快慢指针
        ListNode slowPtr = head, fastPtr = head;
        // 利用快指针作为边界条件
        while (fastPtr.next != null && fastPtr.next.next != null) {
            slowPtr = slowPtr.next; // 慢指针一次走一步
            fastPtr = fastPtr.next.next; // 快指针一次走两步
            if (slowPtr == fastPtr) { // 如果相遇说明有环
                return true;
            }
        }    
        return false;
    }
}

142. 环形链表II

题目

给定一个链表的头节点 head ,返回链表开始入环的第一个节点。 如果链表无环,则返回 null。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos 是 -1,则在该链表中没有环。注意:pos 不作为参数进行传递,仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1:

img

输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。

示例 2:

img

输入:head = [1,2], pos = 0
输出:返回索引为 0 的链表节点
解释:链表中有一个环,其尾部连接到第一个节点。

示例 3:

img

输入:head = [1], pos = -1
输出:返回 null
解释:链表中没有环。

提示:

链表中节点的数目范围在范围 [0, 104] 内
− 1 0 5 < = N o d e . v a l < = 1 0 5 -10^5 <= Node.val <= 10^5 105<=Node.val<=105
pos 的值为 -1 或者链表中的一个有效索引

问题分析

这道是环形链表的变形,在原有判断是否有环的条件下,增加了返回环的第一个节点。

那么思路就是先判断是否有环,然后再去找环中的第一个节点

判断是否有环,直接使用上面的方法,建立快慢双指针,相遇即有环

在相遇的条件下,令慢指针重新指向头节点,并且让两个指针每次都只移动一个节点,这样,两个指针相遇的结点就一定是环中的第一个节点,不然就不会相遇,这里可以自己建个样例画一下

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // 在环形链表1的基础上
    // 先找出是否有环,有环在进行下一步操作,无环则直接返回
    public ListNode detectCycle(ListNode head) {
        if (head == null) return head;
        // 快慢双指针
        ListNode slow = head, fast = head;
        boolean hasCircle = false; // 记录是否有环
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                hasCircle = true;
                break;
            }
        }
        // 有环
        if (hasCircle) {
            slow = head; // 慢指针重新指向head
            while (fast != slow) {
                // 快慢指针都只走一步
                fast = fast.next; 
                slow = slow.next;
            }
            // 相遇的结点就是环的第一个结点
            return slow;
        }
        // 无环返回null
        return null;
    }
}
举报

相关推荐

0 条评论