链表的倒转, 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=null
return 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;
}
扫一扫
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
