力扣爆刷第88天之hot100五连刷26-30

文章目录

- - 力扣爆刷第88天之hot100五连刷26-30
  - [一、142. 环形链表 II](#一、142. 环形链表 II)
  - [二、21. 合并两个有序链表](#二、21. 合并两个有序链表)
  - [三、2. 两数相加](#三、2. 两数相加)
  - [四、19. 删除链表的倒数第 N 个结点](#四、19. 删除链表的倒数第 N 个结点)
  - [五、24. 两两交换链表中的节点](#五、24. 两两交换链表中的节点)

一、142. 环形链表 II

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/description/?envType=study-plan-v2\&envId=top-100-liked

思路：本题让求环形链表的入口，根据一个数学推论，使用快慢指针，慢指针每次走一步，快指针每次走二步，相遇便说明有环，此时从头结点到达环入口节点的距离是等于从相遇节点到入口节点的距离的，然后让其中一个指针指向头结点，另一个指针从相遇节点出发，再次相遇便是入口。

java 复制代码

public class Solution {
   public ListNode detectCycle(ListNode head) {
        ListNode slow = head, fast = head;
        while(fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast) {
                slow = head;
                while(slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return slow;
            }
        }
        return null;
    }
}

二、21. 合并两个有序链表

题目链接：https://leetcode.cn/problems/merge-two-sorted-lists/description/?envType=study-plan-v2\&envId=top-100-liked

思路：很简单的题，新链表有一个虚拟头结点，然后有两个指针遍历两个链表，逐个采用尾插法插入到新链表尾部。

java 复制代码

/**
 * 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) {
        ListNode root = new ListNode();
        ListNode p1 = list1, p2 = list2, p = root;
        while(p1 != null && p2 != null) {
            if(p1.val <= p2.val) {
                p.next = p1;
                p = p.next;
                p1 = p1.next;
            }else{
                p.next = p2;
                p = p.next;
                p2 = p2.next;
            }
            p.next = null;
        }
        if(p1 != null) {
            p.next = p1;
        }
        if(p2 != null) {
            p.next = p2;
        }
        return root.next;
    }
}

三、2. 两数相加

题目链接：https://leetcode.cn/problems/add-two-numbers/description/?envType=study-plan-v2\&envId=top-100-liked

思路：从头结点两两相加，用一个变量记录进位值，即可。

java 复制代码

class Solution {
   public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int res = 0;
        ListNode root = new ListNode();
        ListNode p = root, p1 = l1, p2 = l2;
        while(p1 != null || p2 != null) {
            int v1 = p1 != null ? p1.val : 0;
            int v2 = p2 != null ? p2.val : 0;
            int t = v1 + v2 + res;
            res = t > 9 ? 1 : 0;
            t = t % 10;
            p.next = new ListNode(t);
            p = p.next;
            p1 = p1 != null ? p1.next : null;
            p2 = p2 != null ? p2.next : null;
        }
        if(res == 1) {
            p.next = new ListNode(1);        }
        return root.next;
    }

}

四、19. 删除链表的倒数第 N 个结点

题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/?envType=study-plan-v2\&envId=top-100-liked

思路：快慢指针，快指针先走N个节点，然后快慢一起走。

java 复制代码

class Solution {
   public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode root = new ListNode();
        root.next = head;
        ListNode p = root, slow = root;
        for(int i = 0; i < n; i++) {
            p = p.next;
        }
        while(p != null && p.next != null) {
            slow = slow.next;
            p = p.next;
        }
        slow.next = slow.next.next;
        return root.next;
    }
}

五、24. 两两交换链表中的节点

题目链接：https://leetcode.cn/problems/swap-nodes-in-pairs/description/?envType=study-plan-v2\&envId=top-100-liked

思路：使用三个指针，前两个指针负责交换，后一个指针负责记录下一次要交换的节点对。

java 复制代码

/**
 * 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 swapPairs(ListNode head) {
        if(head == null) return head;
        ListNode root = new ListNode(-1, head);
        ListNode a = root, b = a.next, c = b.next;
        while(c != null) {
            c = c.next;
            a.next = b.next;
            a.next.next = b;
            b.next = c;
            a = a.next;
            if(c != null) {
                a = a.next;
                b = b.next;
                c = c.next;
            }
        }
        return root.next;
    }
}