Leetcode 链表部分笔记

---

1.环形链表

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

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

解答方法：快慢指针，设置两个指针，如果快指针能追上慢指针，则有环，否则返回false

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        if(head == null){
            return false;
        }
        while(fast.next != null && fast.next.next !=null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow== fast){
                return true;
            }
            
        }
        return false;
    }
}

2.两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

解答思路：设置一个新链表，设置两个指针分别指向两个链表的头，设置相加和为指针所指数+进位，如果大于十则让进位变为1，新链表对应位置保存相加和后取余的结果。处理最后的情况，如果最后的进位还是1，则在创建一个节点，保存进位。

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int current = 0;
        ListNode res = new ListNode();
        ListNode head = res;
        while(l1 != null || l2 != null){
            int a = 0;
            int b = 0;
            if(l1 == null){
                a = 0;
            }else{
                a = l1.val;
            }
            if(l2 == null){
                b = 0;
            }else{
                b = l2.val;
            }
            int re = a + b + current;
            current = 0;
            if(re >= 10){
                current = 1;
            }
            res.next = new ListNode(re%10);
            res = res.next;
            if(l1!=null) l1 = l1.next;
            if(l2!=null) l2 = l2.next;
        }
        if(current == 1){
            res.next = new ListNode();
            res = res.next;
            res.val = 1;
        }
        return head.next;
    }
}

3.合并两个有序链表

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

**解题思路：**归并

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null && list2 == null){
            return null;
        }
        ListNode pre = new ListNode();
        ListNode head = pre;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                pre.next = new ListNode(list1.val);
                list1 = list1.next;
            }else{
                pre.next = new ListNode(list2.val);
                list2 = list2.next;
            }
            pre = pre.next;
        }
        if(list1 == null){
            pre.next = list2;
        }
        if(list2 == null){
            pre.next = list1;
        }
        return head.next;
    }
}

4.反转链表II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

解题思路：头插法，设置pre为反转链表前一个节点，current为反转链表的第一个位置，prev作为反转后的链表头，让next保存current的后一个节点，先让current的next指向prev，让prev指向current，也就是往前走一个位置，让current指向原本的后面一个节点。

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 特殊情况处理
        if (head == null || left <= 0 || right < left) {
            return null;
        }

        // 创建虚拟头节点，方便操作
        ListNode dummy = new ListNode(0, head);
        ListNode pre = dummy;

        // 找到反转子链表的前一个节点
        for (int i = 1; i < left; i++) {
            pre = pre.next;
        }

        // 开始反转
        ListNode current = pre.next; // 当前处理节点
        ListNode prev = null;        // 反转后的链表头
        for (int i = 0; i <= right - left; i++) {
            ListNode next = current.next; // 保存下一个节点
            current.next = prev;         // 反转当前节点指针
            prev = current;              // 更新 prev
            current = next;              // 移动到下一个节点
        }

        // 重新连接链表
        pre.next.next = current;  // 子链表尾部连接未反转部分
        pre.next = prev;          // 子链表头部连接前面部分

        // 返回新的链表头
        return dummy.next;
    }
}

5. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

**解题思路：**设置三个指针，start指向被删除的前一个节点，end指向被删除的后面一个节点，tail指向start的后面n个节点，也就是让tail到链表尾部的同时，start正好在被删除前面一个节点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode start = new ListNode(0,head);
        ListNode end = start.next.next;
        ListNode h= start;
        ListNode tail = start;
        if(head.next == null && n==1){
            return null;
        }
        for(int i = 0; i < n; i++){
            tail = tail.next;
        }
        while(tail.next != null){
            start = start.next;
            end = end.next;
            tail = tail.next;
        }
        start.next = end;
        return h.next;
    }
}

6.删除排序链表中的重复元素 II

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

**解题思路：**设置一个prev虚拟头节点，遍历整个链表，判断当前节点和下一个节点是不是相等，如果相等则让head = head.next,即跳过该节点，让prev.next 指向跳过后的head节点，如果不相等，则让head往后走，prev也往后走。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        // 创建虚拟头节点
        ListNode dummy = new ListNode(0, head);
        ListNode prev = dummy;

        while (head != null) {
            // 如果当前节点和下一个节点值相同
            if (head.next != null && head.val == head.next.val) {
                // 跳过所有重复节点
                while (head.next != null && head.val == head.next.val) {
                    head = head.next;
                }
                // 将 prev.next 指向非重复节点
                prev.next = head.next;
            } else {
                // 如果当前节点无重复，直接移动 prev 指针
                prev = prev.next;
            }
            // 移动 head 指针
            head = head.next;
        }

        return dummy.next;
    }
}

7. 旋转链表

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

解题思路：设置两个指针，一个指向旋转链表的头部的前一个节点， 一个在旋转链表的尾部，把尾部节点的next指向原本的头，虚拟头节点指向旋转链表的头。

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        ListNode start = new ListNode(0,head);
        ListNode end = start;
        ListNode h = start;
        ListNode s = start;
        int count = 0;
        if(head == null){
            return null;
        }
        if(head.next == null){
            return head;
        }
        while(s.next != null){
            s = s.next;
            count++;
        }
        if(count == k){
            return head;
        }
        if(count < k){
            k = k%count;
        }
        for(int i = 0; i < k; i++){
            end = end.next;
        }
        while(end.next != null){
            start = start.next;
            end = end.next;
        }

        end.next = head;
        h.next = start.next;
        start.next = null;
        return h.next;
    }
}

8.分割链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。

解题思路：设置两个链表，一个保存大于等于x的，一个保存小于x的，最后接起来。

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode LT = new ListNode();
        ListNode GT = new ListNode();
        ListNode LTH = LT;
        ListNode GTH = GT;
        while(head != null){
            if(head.val < x){
                LT.next = head;
                LT = LT.next;
            }else{
                GT.next = head;
                GT = GT.next;
            }
            head = head.next;
        }
        GT.next = null;
        LT.next = GTH.next;
        return LTH.next;
    }
}