单链表中k个结点一组进行反转

本文介绍了一种单链表处理算法——K组反转。该算法将链表按指定数量K进行分组,并对每组内的节点进行反转。文章详细解释了实现思路与步骤,并提供了完整的Java代码实现。

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

【025-Reverse Nodes in k-Group(单链表中k个结点一组进行反转)】


【LeetCode-面试算法经典-Java实现】【所有题目目录索引】

原题

  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,每K个结点进行反转,如果最后的结点数不足K个就保持原来的链接顺序不变。

解题思路

  用一个指针记录链接好的链表的最后一个结点(tail),用一个指针记录上一次链接好的部分的最后一个结点(head)对未链表的结点在head处进行尾插法,插k个元素,再将head移动到tail处,tail重新记录链表的尾结点,直到所有的元素都进行了操作。如果最后的一组元素不足k个,因为进行过尾插法,所以还要进行还原,对最后的head元素进行尾插法就可以了

代码实现

结点类

public class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

算法实现类

public class Solution {

    public ListNode reverseKGroup(ListNode head, int k) {

        if (k <= 1) {
            return head;
        }

        ListNode root = new ListNode(0);
        // 分组的头一个元素的前驱
        ListNode groupHead = root;
        // 当前要处理的结点
        ListNode curr = head;
        // 处理好的链表的尾结点
        ListNode groupTail = head;
        // 当前要处理的结点的后继
        ListNode next;

        // 对每个组,处理了多少个结点
        int count = 0;


        while (curr != null) {

            // 如果是分组的第一个元素就记录它
            if (count == 0) {
                groupTail = curr;
            }

            // 记录处理的元素个数
            count++;
            // 记录下一个待处理结点
            next = curr.next;
            // 进行尾插法操作
            curr.next = groupHead.next;
            groupHead.next = curr;
            curr = next;

            // 已经处理完了k个结点,分组头的前驱移动到最后一个链接好的结点
            if (count == k) {
                groupHead = groupTail;
                // 计数器归零
                count = 0;
            }
        }


        // 说明结点个数不是k的整数倍,将最后不是整数倍的个元素的结点,
        // 再次使用尾插法进行还原
        if (count != 0) {
            curr = groupHead.next;
            groupHead.next = null;

            while (curr != null) {
                next = curr.next;
                curr.next = groupHead.next;
                groupHead.next = curr;
                curr = next;
            }
        }

        return root.next;
    }
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64

评测结果

  点击图片,鼠标不释放,拖动一段位置,释放后在新的窗口中查看完整图片。

这里写图片描述

特别说明

欢迎转载,转载请注明出处【http://blog.youkuaiyun.com/derrantcm/article/details/47034983

### Python 实现 K 个节点一组翻转链表 以下是基于题目描述和参考资料的 Python 实现方法。该算法满足以下条件: - 反转每 k 个节点的一组。 - 如果剩余节点不足 k 个,则保持原样。 - 算法仅使用 O(1) 的额外空间。 #### 定义链表结构 首先定义单链表的节点类 `ListNode`,这是实现的基础数据结构[^2]。 ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next ``` --- #### 主函数逻辑 主函数负责整体流程控制,包括分组、反转以及连接各部分链表。 ```python def reverseKGroup(head: ListNode, k: int) -> ListNode: dummy = ListNode(0) # 创建哑节点以便于后续操作 dummy.next = head prev_group_end = dummy # 当前已处理部分的最后一节点 while True: a = prev_group_end.next # 获取当前组的第一个节点 if not has_k_nodes(a, k): # 判断是否有足够的 k 个节点 break b = get_kth_node(a, k) # 到第 k+1 个节点 (即下一组的起点) new_a = reverse_list(a, b) # 对 [a, b) 节点范围内的子链表进行反转 # 连接已经完成的部分与新反转的部分 prev_group_end.next = new_a prev_group_end = a # 更新 prev_group_end 为本组最后一个节点(原始的 a) return dummy.next def has_k_nodes(node: ListNode, k: int) -> bool: """判断从给定节点开始是否存在至少 k 个节点""" current = node count = 0 while current and count < k: current = current.next count += 1 return count == k def get_kth_node(start: ListNode, k: int) -> ListNode: """获取从 start 开始的第 k+1 个节点""" current = start for _ in range(k): if not current: break current = current.next return current def reverse_list(start: ListNode, end: ListNode) -> ListNode: """反转从 start 到 end 前一个节点之间的链表""" prev, curr = None, start while curr != end: temp_next = curr.next curr.next = prev prev = curr curr = temp_next return prev ``` --- #### 测试代码 为了验证上述实现的有效性,可以编写测试用例来观察结果。 ```python # 辅助函数:创建链表 def create_linked_list(values): dummy = ListNode() current = dummy for value in values: current.next = ListNode(value) current = current.next return dummy.next # 辅助函数:打印链表 def print_linked_list(head): result = [] while head: result.append(str(head.val)) head = head.next print("->".join(result)) # 测试用例 if __name__ == "__main__": test_values = [1, 2, 3, 4, 5] k = 2 head = create_linked_list(test_values) reversed_head = reverseKGroup(head, k) print_linked_list(reversed_head) # 输出应为 2->1->4->3->5 ``` --- ### 解决方案说明 以上代码实现了按每 k 个节点一组翻转链表的功能,并遵循了以下原则: - **O(1) 额外空间**:除了几个指针变量之外未使用其他存储资源[^1]。 - **边界情况处理**:当剩余节点少于 k 时不会执行任何反转操作。 - **哑节点优化**:引入哑节点简化了头结点可能变动的情况下的复杂度[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值