leetcode打卡4.10

[82. 删除排序链表中的重复元素 II]

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

/**
 * 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) {
        ListNode dummy = new ListNode(0, head);
        ListNode left = dummy;
        ListNode right = head;
        while(right != null) {
            // 此时right不是重复值
            if(right.next == null || right.val != right.next.val) {
                left.next = right;
                left = left.next;
            }
            // 过滤重复节点
            while(right.next != null && right.val == right.next.val) {
                right = right.next;
            }
            // right节点还是重复值，需要再往后移一个
            right = right.next;
        }
        // right=null 应对链表值全重复的情况
        left.next = right;
        return dummy.next;
    }
}

• 解题思路：

• 复杂度分析
  • 时间复杂度：O(n)，n为链表长度
  • 空间复杂度：O(1)

[25. K 个一组翻转链表]

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

/**
 * 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 reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0, head);
        ListNode h1 = head;
        ListNode pre = head;
        ListNode newHead = head;
        int cnt = 0;
        while(h1 != null) {
            cnt++;
            pre = h1;
            h1 = h1.next;
            if(cnt == k) {
                pre.next = null;
                // 反转前 k 个元素
                newHead = reverse(dummy.next);
                head.next = reverseKGroup(h1, k);
            }
        }
        // 剩余数量小于k的话，则不需要反转
        if(cnt < k) return head;
        return newHead;
    }

    // 反转链表
    public ListNode reverse(ListNode list) {
        ListNode pre = null;
        ListNode next = list;
        while(list != null) {
            next = list.next;
            list.next = pre;
            pre = list;
            list = next;
        }
        return pre;
    }
}

• 解题思路：代码写得有点啰嗦，题解推荐. - 力扣（LeetCode）

• 复杂度分析
  • 时间复杂度：O(n)，n为链表长度，要进行O(n/k)次反转，每次反转需的时间复杂度为O(k)
  • 空间复杂度：O(n)?，栈空间的调用

[24. 两两交换链表中的节点]

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

/**
 * 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) {
        // 要交换的节点数小于2 直接返回
        if(head == null || head.next == null) return head;

        ListNode newHead = head.next;
        newHead.next = head;
        head.next = swapPairs(newHead.next);
        return newHead;
    }
}

• 解题思路：

• 复杂度分析
  • 时间复杂度：O(n)，n为链表长度
  • 空间复杂度：O(n)，栈空间的调用