一. 反转链表

题目链接：https://leetcode.cn/problems/reverse-linked-list/

1. 思路简述

三个指针进行迭代，pre指向前驱，cur是当前指针，nxt为后继指针。
cur.next指向pre，实现链表的反转。

2. 代码

/**
 * 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; }
 * }
 */
public ListNode reverseList(ListNode head) {
    ListNode pre, cur, nxt;
    pre = null; cur = head; nxt = head;

    while(cur != null){
    	//寻找后继节点
        nxt = cur.next;
        //反转链表
        cur.next = pre;
		//pre，cur两个指针同步向前移动
        pre = cur;
        cur = nxt;
    }
    return pre;
}

3. 总结

时间复杂度：o(n)
空间复杂度：o(1)，比递归要省空间，递归需要栈。
把循环里的步骤分块理解，会好很多。

二. K 个一组翻转链表

题目链接：https://leetcode.cn/problems/reverse-nodes-in-k-group/

1. 思路简述

以k值为单位，分组进行递归式反转；如果剩下的元素个数不够k个，直接将后面的链表原样输出。
reverse函数就是根据反转链表改来的，只不过，反转链表是[ head,null ）进行反转，而这里的反转算法换成了[ a , b )进行反转，a为每一个分组的头结点。
for循环真的很巧妙，刚好b最后指的是要反转链表的后一个节点，时刻记得左闭右开。a相当于反转链表当中的头结点，b就相当于反转链表中的null，如下图：
以这个题为例，程序执行完成后的链表应该是如下这张图的样子：

2. 代码

ListNode reverse(ListNode a, ListNode b) {
    ListNode pre, cur, nxt;
    pre = null; cur = a; nxt = a;
    // while 终止的条件改一下就行了
    while (cur != b) {
        nxt = cur.next;
        cur.next = pre;
        pre = cur;
        cur = nxt;
    }
    // 返回反转后的头结点
    return pre;
}

public ListNode reverseKGroup(ListNode head, int k) {
    if(head == null)
        return null;
    ListNode a, b;
    a = head; b = head;

	//这个循环真的很巧妙，刚好b最后指的是要反转链表的后一个节点，时刻记得左闭右开
    for(int i = 0; i < k; i++){
    	//如果b == null，也就是说这个分组已经不够k个，直接将它原样输出
        if(b == null){
            return head;
        }
        //否则，继续向下遍历
        b = b.next;
    }
	
    ListNode newHead = reverse(a, b);
    //这里的a是当前的头结点，也就是没有反转前本小组的头结点。
    //因为是左闭右开，所以子问题要从b开始。
    //将各个反转后的链表连在一起，看不懂就参考上面那张图
    a.next = reverseKGroup(b, k);
    return newHead;
}