链表双指针应用

21 合并两个有序双链表

LeetCode 21.合并两个有序双链表

题目

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

示例 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 均按 非递减顺序 排列

问题分析

双指针

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

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

/**
 * 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 删除排序链表中的重复元素

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

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

示例 1：

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

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

提示：

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

问题分析

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

/**
 * 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