【Java - L - 0025】h - x - K 个一组翻转链表

题目描述

lc练习

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

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

• 示例：
  给你这个链表：1->2->3->4->5
  当 k = 2 时，应当返回: 2->1->4->3->5
  当 k = 3 时，应当返回: 3->2->1->4->5

J - 24】反转链表

K实现

实现方法

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null || head.next == null) return head;

        /** 定义head的前一个节点--假节点 */
        ListNode virtualHead = new ListNode(0);
        virtualHead.next = head;

        /** 初始化pre和end都指向virtualHead */
        ListNode pre = virtualHead; // pre指每次要翻转的链表的头结点的上一个节点。
        ListNode end = virtualHead; // end指每次要翻转的链表的尾节点

        while (end.next != null) {
            /** 循环k次，找到翻转部分的头尾 */ //virtualHead->1->2->3->4->5 若k为2，循环2次，end指向2
            for (int i = 0; i < k && end != null; i++) { // 这里每次循环要判断end是否等于空,因为如果为空，end.next会报空指针异常。
                end = end.next;
            }
            if (end == null) { //需要翻转的链表的节点数小于k，不执行翻转。
                break;
            }

            /** 记录下一块的第一个节点并断开 */
            ListNode next = end.next;
            
            /** 翻转本组的链表*/
            end.next = null; //断开链表->分段翻转
            ListNode start = pre.next; //记录下要翻转链表的头节点
            pre.next = reverse(start); // reser返回头 头2和前面连接，尾1和后面连接 1->2 变成2->1。 virtualHead->2->1

            /** 把子链表重新接回原链表 */
            start.next = next; //翻转后头节点移到。通过.next把断开的链表重新链接。

            /**继续遍历下一组*/
            pre = start; //将pre换成下次要翻转的链表的头结点的上一个节点。即start
            end = start; //翻转结束，将end置为下次要翻转的链表的头结点的上一个节点。即start
        }
        return virtualHead.next;
    }

    /**
     * 链表翻转 head： 1->2->3->4
     */
    public ListNode reverse(ListNode head) {
        //单链表为空或只有一个节点，直接返回原单链表
        if (head == null || head.next == null) return head;

        ListNode pre = null;  //前一个节点指针
        ListNode cur = head; //当前节点指针
        ListNode next = null; //下一个节点指针

        while (cur != null) {
            next = cur.next;//next 指向下一个节点,保存当前节点后面的链表。
            cur.next = pre;//将当前节点next域指向前一个节点   null<-1<-2<-3<-4
            pre = cur;//pre 指针向后移动。pre指向当前节点。
            cur = next;//cur指针向后移动。下一个节点变成当前节点
        }
        return pre;
    }
}

K=2实现

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if(head==null||head.next==null) return head;

        ListNode  virtualHead= new ListNode(0);
        virtualHead.next = head;

        ListNode pre = virtualHead;
        ListNode end = virtualHead;

        while(end.next!=null){
            for(int i =0;i<2&&end!=null;i++){ // ① k=2
                end =end.next;
            }
            if(end==null){
                break;
            }

            ListNode next = end.next;

            end.next =null;
            ListNode start =pre.next;
			/** ② k=2 */
            // pre.next=reverse(start);
			pre.next = end;
			end.next = start;

            start.next=next;

            pre =start;
            end=start;
  
        }
        return virtualHead.next;
   
    }
}