链表的倒转, K个一组倒转问题

准备工作

准备好节点:

public class Node<T> {public Node next;public T value;}

以及初始化一个链表的代码

public class NodeUtil {/*** 准备工作 准备一个链表* @param n* @return*/public static Node<Integer> prepare(int n) {Node<Integer> pre = null, head = null;for (int i = 0; i < n; i++) {Node<Integer> node = new Node<>();node.setValue(i);if (pre != null) {pre.setNext(node);} else {head = node;}pre = node;}return head;}public static void print(Node<Integer> head) {Node e = head;while (e != null) {System.out.print(e.getValue());e = e.getNext();}System.out.println("");System.out.println("========");}}

倒转

链表的倒转, 这里写下两种思路.

遍历法
递归法

遍历法

可以想象成扑克牌, 链表的话想象成扑克牌一张张平铺好. 我们需要倒转这个顺序的话, 从左到右, 只需要把第一张放到第二张下面(node(第二张).next = pre(第一张)), 第二张放到第三张下面, 以此类推, 堆好就是倒序的, 如图:

这里有个坑, 就是节点是从第一个开始, 假如链表是1,2,3,4,5, 即 1 - 2 - 3 - 4 - 5, 按上面的说法, 假如我们理所当然的从第二张开始, 将第一张放到第二张下面, 即我们认为手拿好 2-1, 桌子上 3 - 4 - 5, 就会有问题, 因为 1还是指向2. 即使把后面3-4-5也这样倒转, 5-4-3-2-1-2, 这里会一个闭环导致死循环. 所以我们不要忽视1前面还有一个虚拟节点null. 即null-1-2-3-4-5-null. 从1开始遍历

要把当前节点的next设置为pre上个节点
因为是单向链表, 所以我们需要一个变量pre记录上一个节点, 以便我们将当前这个节点的next设置为上个节点
其次因为涉及到两个节点互换, 我们也需要一个中间变量cur来临时保存

public static Node reverseList2(Node node){if(node == null || node.next == null){return node;}Node pre = null;Node cur = null;while(node != null)  {cur = node;//先保存当前节点的下个节点, 否则就覆盖了Node next = cur.next;cur.next = pre;//节点往后走一,用于下次遍历node = next;//同时pre变量也要变pre = cur;}//注意这里是cur不是node,因为node在循环结束后是next=nullreturn cur;
}public static void main(String[] args) {//    print(head);Node reverse = reverseList2(prepare(10));print(reverse);}

递归法

思路

什么时候递归? 这关系到翻转的顺序, 如果先递归再翻转, 则节点会递归到最后一个, 翻转也是从后往前翻转. 如果先翻转再递归, 就是从前往后.

但是由于链表是next单向往后的, 如果从前往后翻转递归, 就必然会要覆盖掉下一个递归节点的next, 比如1-2-3-4, 在节点1的时候翻转1-2变成2-1, 导致2到3-4-5的链接断开. 因此不如从后往前翻转
确定了是从后往前翻转, 那么开始尝试写伪代码

//1. 跳出条件,因为需要将下个节点的next指向自己, 所以应该是节点以及下个节点不能为空

//2. 递归的代码

//3. 翻转

//4. 返回

public static Node reverseList1(Node node){if(node == null || node.next == null){return node;}//取得下个节点来递归Node next = node.next;//这里返回的是节点的最后一个节点,因为递归到底了` node.next == null`返回 Node head = reverseList1(next); //走到翻转的肯定是倒数第二个节点,如1-10的链表则node是9.next是10//需要切断和下个节点的指向,否则会闭环node.next = null; //将该节点和下个节点顺序换下next.next = node;return head;}

测试

  public static void main(String[] args) {Node reverse1 = reverseList1(prepare(10));print(reverse1);Node reverse2 = reverseList2(prepare(10));print(reverse2);}

9876543210==============
9876543210==============

如果不能理解的话, 想象一个1-10的链表, 最后走到翻转的递归node肯定是9, 因为next=10, 直接因为node.next == null返回, 递归的node是9, next是10, 将9的next=null, 将10的next=9, . 所以是10-9-null, 外一层递归则是10-9-8-null以此类推.

k组倒转

题目：

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

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

示例 :

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

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

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

两种思路

将k个一组分别调用上面的完全翻转方法
尾插法, 将前k-1的节点依次插入到k节点下. 注意这里的意思不是插入到最后面tail. 举例假如1-2-3要倒转, 分别将1和2插入到3后面. 先是2-3-1, 然后3-2-1

完全翻转法

链表翻转方法就直接调用上面的reverseList1()

需要考虑在最开始加一个虚拟节点result, 因为倒转是从1开始, 我们在最前面定一个边界, 同时也是为了避免翻转后head节点变化我们找不到链表头.
然后我们还需要一个临时变量pre, 因为每次翻转一组, 我们需要把它和前一组连接, 所以pre就是上一组的最后一个点
然后我们需要在一个大循环中, 加一个小循环. 大循环是为了把不同组翻转, 小循环是为了确认出一组的范围
然后在确定了k个节点的区间后, 我们先保存后面的一段next, 然后在边界处断开连接, 然后交给翻转方法进行翻转
翻转后, 再将翻转后的把后面next的链接起来, 也同时和前面的pre连接起来

public static Node reverseK(Node node,int k){//1.先常规判断if(node == null || node.next == null || k < 1){return node;}//虚拟节点Node result = new Node();result.next = node;    //临时变量,初始化就是result. 因为它也是虚拟上一组的最后一个节点Node pre = result;//大循环while(node != null){//这一组的开始节点就是node, 结束节点是end. 这里不要写错成pre.next了. 因为下面的遍历i=0的时候,end才在这一段的第一个节点.Node end = pre;int n = 0;for(int i = 0;i < k & end != null; i++){//一直找到边界结尾end = end.next;    n++;}    if(n < k){//说明这一段不足k个, 就end=null到了最后break;}//确定了区间是node-end这段.// 先保存后面一段, 然后切断Node next = end.next;end.next = null;Node head = reverseList1(node);//此时是翻转后的, node本身是start边界,翻转后变成了最后,因此将它和原本的后面一段连接node.next = next;//再和前面的链接起来pre.next = head;//往后遍历,节点后移pre = node;node = next;}    return result.next;}

  public static void main(String[] args) {Node node = reverseK(prepare(10), 3);print(node);}//测试结果
2105438769

尾插法

前面的思路, 直到分出k个大小的区段时和完全翻转一样
但是到了翻转的部分, 这里还需要做一个小循环. 把前面k-1个数插入到k后面
小循环结束后, 其实也就是翻转结束, 同样的和前面一段的最后一个节点衔接起来, 和下个区段的头一个节点衔接. 所以定义一个pre变量表示前面一个区段, 最后一个节点
和上面一样, 为了方便我们处理第一个节点, 我们在前面设置一个虚拟节点result

public static Node reverseK2(Node node, int k){if(node == null || node.next== null || k < 1 ){return node;}//在1的前面位置0, 设置虚拟节点Node result = new Node();result.next = node;//设置临时变量, 表示上个区段的最后一个节点, 用于翻转后衔接Node pre = result;while(node != null){int n = 0;Node end = pre;//分出k个节点作为区段for(int i = 0; i<k && end != null; i++){end = end.next;n ++;}//不足k个直接跳出if(n < k){break;}//记录原本的开始下标, 翻转后这个是结束的下标Node start2end = node;//遍历前面k-1个, 将其插入到end后for(int i=0; i < k-1;i++){//同样要保存避免覆盖Node endnext =  end.next;Node next = node.next;//插入end后, 准确的说是end和end.next之间end.next = node;node.next = endnext;//作为下次循环node = next;}//开始将区段前后两边衔接//衔接前面的区段, 此时end翻转到该区段最前面pre.next = end;//作为下次循环pre = start2end;node = pre.next;}//虚拟节点后面的就是我们需要的return result.next;
}