Reverse Nodes in k-Group

最新推荐文章于 2022-04-08 22:28:12 发布

原创最新推荐文章于 2022-04-08 22:28:12 发布 · 446 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode_Java 专栏收录该内容

121 篇文章

订阅专栏

本文介绍一种算法，用于将链表每K个节点进行翻转，并保持剩余节点不变。该方法仅改变节点指向，不修改节点值，并且只使用常数内存。通过实例演示了当K为2和3时的链表变化过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.

If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.

You may not alter the values in the nodes, only nodes itself may be changed.

Only constant memory is allowed.

For example,
Given this linked list: 1->2->3->4->5

For k = 2, you should return: 2->1->4->3->5

For k = 3, you should return: 3->2->1->4->5

从起始节点开始遍历，如意如果k ＝ 1的时候，也是返回原来链表，要注意程序中两次注释中出错的地方

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null ||k <= 1 ) {
            return head;
        } 
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode beforeStart = dummy;
        ListNode start = head;
        ListNode end = head;
        ListNode afterEnd = end.next; 
        int count = 1;
        while(end != null) {
            if (count == k) {
                afterEnd = end.next;
                reverse(start, end);
                beforeStart.next = end;
                beforeStart = start;
                //要把start.next 设为 afterEnd, 之前漏掉这一步，出错
                start.next = afterEnd;
                end = start;
                start = afterEnd;
                count = 0;
            }
            end = end.next;
            count++;
        }
        return dummy.next;
    }
    void reverse(ListNode start, ListNode end) {
        ListNode dummy = new ListNode(-1);
        dummy.next = start;
        ListNode pre = dummy;
        ListNode cur = dummy.next;
        ListNode next = cur.next;
        //这里要考虑如果end.next == null,那么下面循环中next.next 就会有空指针错误，
        //所以这里把要转换的最后一个node，也就是end， 单独拿出来转换
        while(next != end.next) {
            cur.next = pre;
            pre = cur;
            cur = next;
            next = next.next;
        }
        cur.next = pre;
    }
}

别人的解法：
这里是先计算出了链表中有几个k，则有几次转换，我上面的写法比这种方法只少了一次循环，时间复杂度是一样的，都是o(n)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null ||k <= 1 ) {
            return head;
        } 
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode beforeStart = dummy;
        ListNode start = head;
        ListNode end = head;
        ListNode afterEnd = end.next; 
        int count = 1;
        while(end != null) {
            if (count == k) {
                afterEnd = end.next;
                reverse(start, end);
                beforeStart.next = end;
                beforeStart = start;
                //要把start.next 设为 afterEnd, 之前漏掉这一步，出错
                start.next = afterEnd;
                end = start;
                start = afterEnd;
                count = 0;
            }
            end = end.next;
            count++;
        }
        return dummy.next;
    }
    void reverse(ListNode start, ListNode end) {
        ListNode dummy = new ListNode(-1);
        dummy.next = start;
        ListNode pre = dummy;
        ListNode cur = dummy.next;
        ListNode next = cur.next;
        //这里要考虑如果end.next == null,那么下面循环中next.next 就会有空指针错误，
        //所以这里把要转换的最后一个node，也就是end， 单独拿出来转换
        while(next != end.next) {
            cur.next = pre;
            pre = cur;
            cur = next;
            next = next.next;
        }
        cur.next = pre;
    }
}