前言
链表一种常见的数据结构
链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构,操作复杂。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表的反转
链表的反转目前主要包含3种
1.整个链表的反转
2.从链表的头节点开始的前N个节点
3.反转链表的指定M到N的节点 M>=1
首先开始第一节操作
1. 整个链表的反正
1.1 方法一 非递归 代码不是很优雅 但不容易造成栈溢出
直接上代码
/**
* 单链表节点的结构
*/
static class ListNode {
ListNode next;
int val;
ListNode(int x) {
this.val = x;
}
}
//定义一个1到6的链表
private static final ListNode HEAD;
static {
HEAD = new ListNode(1);
ListNode two = new ListNode(2);
ListNode three = new ListNode(3);
ListNode four = new ListNode(4);
ListNode five = new ListNode(5);
ListNode six = new ListNode(6);
HEAD.next = two;
two.next = three;
three.next = four;
four.next = five;
five.next = six;
six.next = null;
}
public ListNode revertList(ListNode head) {
//当前节点从 头节点开始
ListNode cur = head;
ListNode pre = null;
ListNode tmp;
while (cur != null) {
//记录当前节点下一个节点
tmp = head.next;
cur.next = pre;
pre = cur;
cur = tmp;
}
return pre;
}
循环的思路简单列出来
这里将链表中节点的数字展示出来 方便理解
输入 1->2->3->4->5->6
第一次循环 cur = head = 1 tmp = 2 cur.next = 之前1->2 -----> 1->null pre = 1 cur = 2
第二次循环 tmp = 3 cur.next = 之前 2->3 -----> 2->1 pre = 2 cur= 3
第三次循环 tmp =4 cur.next = 之前 3->4 -----> 3->2 pre = 3 cur= 4
第四次循环 tmp=5 cur.next = 之前 4->5 -----> 4--> 3 pre = 4 cur = 5
第五次循环 tmp=6 cur.next = 之前 5->6 -----> 5->4 pre = 5 cur= 6
第六次循环 tmp = null cur.next = 之前 6->null ----> 6->5
返回
1.2 递归方案 方法简单粗暴
public static ListNode revert(ListNode head) {
if (head.next == null) {
return head;
}
// 6
ListNode last = revert(head.next);
System.out.println("last: " + last.val);
System.out.println("head:" + head.val);
System.out.println("head next :" + head.next.val);
head.next.next = head;
System.out.println("赋值head:" + head.val);
head.next = null;
return last;
}
配置打印的注释帮助理解一波
原有链表 1->2->3->4->5->6
第一次 方法进行调用时 1 revert 参数 ->1
第二次 2. revert 参数 -> 2
第三次 3 revert 参数 -> 3
第四次 4. revert 参数 -> 4
第五次 5.revert 参数 -> 5
第六次 6.revert 参数 ->6 return last 6 方法结束
回到第五次 head = 5 head.next.next= 6.next = 5 5->6 6->5 成环
下一步操作 head.next = null 5.next = null 即此时链表恢复正常 6->5 返回 last = 6
第四次 head = 4 head.next.next= 5.next =4 4->5 5->4 成环
下一步操作 head.next = null 4.next =null 返回 上一步操作 链表为 6->5 经过此次操作 5->4 最后此时链表为 6->5->4 返回 last=6
第三次 head = 3 head.next.next= 3.next =3 3->4 4->3 成环
下一步操作 head.next = null 3.next =null 返回 最后此时链表为 6->5->4->3 返回 last=6
第二次 head = 2 head.next.next= 2.next=2 2->3 3->2 成环
下一步操作 head.next = null 2.next =null 返回 最后此时链表为 6->5->4->3->2 返回 last=6
第一次操作 head =1 head.next.next= 2.next=1 1->2 2->1 成环
下一步操作 head.next = null 1.next = null 返回 最后此时链表为 6->5->4->3->2->1 返回 last=6
至此操作翻转完成
以上常见两种反转链表操作
2. 反转链表的前N个节点
private static ListNode successor;
/**
* 反转链表前 N 个节点
*
* @param head head
* @param n n
* @return ListNode
*/
private static ListNode revertN(ListNode head, Integer n) {
if (n == 1) {
// 记录第 n + 1 个节点
successor = head.next;
return head;
}
ListNode last = revertN(head.next, n - 1);
head.next.next = head;
head.next = successor;
return last;
}
revertN(HEAD,3) head = 1 n =3
第二次 head.next =2 n-1=3-1=2
第三次 head.next =3 n-1 = 2-1 = 1 返回 head =3
返回第二次 head =2 2.next.next = head -----> 2->3->4->5->6 ---> 2->3->2 head.next = 3->2->4->5->6
第二步重点 2->3->2 2.next = 2->4 但是 3还是->2的 也就变成 3->2->4->5->6
返回第一次 head =1 1.next.next= 1->2->3 ---> 1--->2-->1 head.next= = 1-> 4 = 3->2->1->4->5->6
第一步重点 1->2->1 1.next =1->4 但是 2还是->1的 也就变成 3->2->1->4->5->6
3. 反转链表的m - n个节点 其中m>=1
private static ListNode revertBetween(ListNode head, Integer m, Integer n) {
if (m == 1) {
return revertN(head, n);
}
// 前进到反转的起点触发 base case
head.next = revertBetween(head.next, m - 1, n - 1);
return head;
}
第一次 revertBetween(HEAD,3,5) 实际传入值 head=1 m=3 n=5
第二次调用 head=1 head.next=2 m-1=2 n-1=4 实际传入值 head=2 m=2 n=4
第三次调用 head=2 head.next=3 m-1=1 n-1=3 回到 revertN(3,3)
进入 revertN(3,3) 3->4->5->6 反转前3个 返回 5->4->3->6
回到第二次 head =2 head.next = 2->5->4->3->6
回到第一次 head = 1 head.next = 1->2->5->4->3->6
4. 循环反转 a->b之间的节点
/**
* 反转a->b节点
*
* @param a a
* @param b b
* @return ListNode
*/
private static ListNode reverse(ListNode a, ListNode b) {
ListNode cur = a;
//pre = a
ListNode pre = null;
ListNode next;
while (cur != b) {
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
进阶 K 个一组反转链表
/**
* k个节点一组翻转链表
*
* @param head head
* @param k k
* @return ListNode
*/
private static ListNode reverseGroup(ListNode head, int k) {
ListNode b = head;
for (int i = 0; i < k; i++) {
if (b == null) {
return head;
}
b = b.next;
}
ListNode newHead = reverse(head, b);
head.next = reverseGroup(b, k);
return newHead;
}
学习文章 递归反转链表:如何拆解复杂问题
good day !!!