leetcode刷题笔记二十五 K 个一组翻转链表 Scala版本

问题描述：

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

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明：

你的算法只能使用常数的额外空间。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

代码补充：

//拿到这个题目的时候，第一想法是通过栈对K个元素进行管理，将前K个元
//素入栈，然后依次弹出重构链表
//查阅相关资料，发现更好的方法主要是递归法，相对于使用栈管理，对空
//间和时间有了一些提升
//将问题进行分解，链表分解出K长度、三指针分解后的链表倒叙和对之后的链表进行重复操作
/**
 * Definition for singly-linked list.
 * class ListNode(var _x: Int = 0) {
 *   var next: ListNode = null
 *   var x: Int = _x
 * }
 */
object Solution {
    def reverseKGroup(head: ListNode, k: Int): ListNode = {
    		//当链表为空或只有一个节点或者k=1，直接返回
            if(head == null || head.next == null || k == 1) return head
			
			//设立a b指针用来获取K长度的指针
            var a = head
            var b = head

			//将b指针向右移动K次，如果不到K次直接返回
            for( i <- 0 until k ){
                if (b == null) return head
                b = b.next
            }

			//对本次获取的K长度的链表进行倒叙
            val ans = reverse(a,b)
            //此时a为最右节点，对其后链表进行处理
            a.next = reverseKGroup(b,k)
            return ans
    }
	
    //通过三指针进行两个节点间倒序，通过循环多次执行达到链表倒叙
    def reverse(a:ListNode, b:ListNode):ListNode = {
        var pre:ListNode = null
        var cur = a
        var nxt = a

        while (cur != b) {
            nxt = cur.next
            cur.next = pre
            pre = cur
            cur = nxt
        } 
        return pre
    }
}

补充：