备战Java后端【Day5】
数据结构1-1
链表5
- k个一组反转链表
- 回文链表
学习目标
- 复习Day1至Day4内容
- 递归根据k个一组反转链表
- 回文链表
学习内容
单链表k个一组反转操作
- 思想: 链表是一种兼具递归和迭代性质的数据结构,因此k个一组进行链表反转具有递归性质。
比如说我们对这个链表调用 reverseKGroup(head, 2),即以 2 个节点为一组反转链表:
如果我设法把前 2 个节点反转,那么后面的那些节点怎么处理?后面的这些节点也是一条链表,而且规模(长度)比原来这条链表小,这就叫子问题。
我们可以把原先的 head 指针移动到后面这一段链表的开头,然后继续递归调用 reverseKGroup(head, 2),因为子问题(后面这部分链表)和原问题(整条链表)的结构完全相同,这就是所谓的递归性质。
发现了递归性质,就可以得到大致的算法流程:
-
先反转以 head 开头的 k 个元素
-
将第 k+1 个元素作为 head 递归调用 reserseKGroup 函数
-
将上述两个过程的结果连接起来
整体思路就是这样了,最后一点值得注意的是,递归函数都有个 base case,对于这个问题是什么呢?
题目说了,如果最后的元素不足 k 个,就保持不变。这就是 base case,待会会在代码里体现。
回文链表
回文串,是指一个正读和反读都一样的字符串。顾名思义,回文链表就是一个正向遍历和反向遍历得到结果都一样的链表。
寻找回文串的核心思想是从中心向两端扩展:
// 在 s 中寻找以 s[left] 和 s[right] 为中心的最长回文串
String palindrome(String s, int left, int right) {
// 防止索引越界
while (left >= 0 && right < s.length()
&& s.charAt(left) == s.charAt(right)) {
// 双指针,向两边展开
left--;
right++;
}
// 返回以 s[left] 和 s[right] 为中心的最长回文串
return s.substring(left + 1, right);
}
因为回文串长度可能为奇数也可能是偶数,长度为奇数时只存在一个中心点,而长度为偶数时存在两个中心点,所以上面这个函数需要传入 1 和 r。
而判断一个字符串是不是回文串就简单很多,不需要考虑奇偶情况,只需要 双指针技巧,从两端向中间逼近即可:
boolean isPalindrome(String s) {
// 一左一右两个指针相向而行
int left = 0, right = s.length() - 1;
while (left < right) {
if (s.charAt(left) != s.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}
因为回文串是对称的,所以正着读和倒着读应该是一样的,这一特点是解决回文串问题的关键。
- 一、判断回文单链表
输入一个单链表的头结点,判断这个链表中的数字是不是回文,函数签名如下:
boolean isPalindrome(ListNode head);
比如说:
输入: 1->2->null
输出: false
输入: 1->2->2->1->null
输出: true
然而对于单链表来说,单链表无法倒着遍历,无法使用双指针技巧。
那么最简单的办法就是,把原始链表反转存入一条新的链表,然后比较这两条链表是否相同。
其实,借助二叉树后序遍历的思路,不需要显式反转原始链表也可以倒序遍历链表,下面对于二叉树的几种遍历方式,如下所示:
void traverse(TreeNode root) {
// 前序遍历代码
traverse(root.left);
// 中序遍历代码
traverse(root.right);
// 后序遍历代码
}
链表兼具递归结构,树结构不过是链表的衍生。那么,链表其实也可以有前序遍历和后序遍历:
void traverse(ListNode head) {
// 前序遍历代码
traverse(head.next);
// 后序遍历代码
}
如果我想正序打印链表中的 val 值,可以在前序遍历位置写代码;反之,如果想倒序遍历链表,就可以在后序遍历位置操作:
/* 倒序打印单链表中的元素值 */
void traverse(ListNode head) {
if (head == null) return;
traverse(head.next);
// 后序遍历代码
print(head.val);
}
可以稍作修改,模仿双指针实现回文判断的功能:
// 左侧指针
ListNode left;
boolean isPalindrome(ListNode head) {
left = head;
return traverse(head);
}
boolean traverse(ListNode right) {
if (right == null) return true;
boolean res = traverse(right.next);
// 后序遍历代码
res = res && (right.val == left.val);
left = left.next;
return res;
}
实际上就是把链表节点放入一个栈,然后再拿出来,这时候元素顺序就是反的,只不过我们利用的是递归函数的堆栈而已
当然,无论造一条反转链表还是利用后序遍历,算法的时间和空间复杂度都是 O(N)。
- 二、优化空间复杂度
1、先通过 双指针技巧 中的快慢指针来找到链表的中点:
ListNode slow, fast;
slow = fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
// slow 指针现在指向链表中点
2、如果 fast 指针没有指向 null,说明链表长度为奇数,slow 还要再前进一步:
if (fast != null)
slow = slow.next;
3、从 slow 开始反转后面的链表,现在就可以开始比较回文串了:
ListNode left = head;
ListNode right = reverse(slow);
while (right != null) {
if (left.val != right.val)
return false;
left = left.next;
right = right.next;
}
return true;
至此,把上面 3 段代码合在一起就高效地解决这个问题了,其中 reverse 函数很容易实现。
boolean isPalindrome(ListNode head) {
ListNode slow, fast;
slow = fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
if (fast != null)
slow = slow.next;
ListNode left = head;
ListNode right = reverse(slow);
while (right != null) {
if (left.val != right.val)
return false;
left = left.next;
right = right.next;
}
return true;
}
ListNode reverse(ListNode head) {
ListNode pre = null, cur = head;
while (cur != null) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
算法总体的时间复杂度 O(N),空间复杂度 O(1),已经是最优的了。这种解法虽然高效,但破坏了输入链表的原始结构。其实这个问题很好解决,关键在于得到 p ,q 这两个指针位置:
这样,只要在函数 return 之前加一段代码即可恢复原先链表顺序
p.next = reverse(q);
-
首先,寻找回文串是从中间向两端扩展,判断回文串是从两端向中间收缩。对于单链表,无法直接倒序遍历,可以造一条新的反转链表,可以利用链表的后序遍历,也可以用栈结构倒序处理单链表。
-
具体到回文链表的判断问题,由于回文的特殊性,可以不完全反转链表,而是仅仅反转部分链表,将空间复杂度降到 O(1)。
学习时间
2022年5月30日
- 下午5点-下午6点
- 晚上7点-晚上9点
学习产出
- 本文档链表基础知识和基础操作
- 力扣25题,K个一组翻转链表
- 力扣234题,回文链表
今日刷题
25.K个一组翻转链表
输入 head,reverseKGroup 函数能够把以 head 为头的这条链表进行翻转。我们要充分利用这个递归函数的定义,把原问题分解成规模更小的子问题进行求解。
- 1、先反转以 head 开头的 k 个元素。
- 2、将第 k + 1 个元素作为 head 递归调用 reverseKGroup 函数。
- 3、将上述两个过程的结果连接起来。
最后函数递归完成之后就是这个结果,完全符合题意:
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null) return null;
// 区间 [a, b) 包含 k 个待反转元素
ListNode a, b;
a = b = head;
for (int i = 0; i < k; i++) {
// 不足 k 个,不需要反转,base case
if (b == null) return head;
b = b.next;
}
// 反转前 k 个元素
ListNode newHead = reverse(a, b);
// 递归反转后续链表并连接起来
a.next = reverseKGroup(b, k);
return newHead;
}
/* 反转区间 [a, b) 的元素,注意是左闭右开 */
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;
}
}
234.回文链表
这道题的关键在于,单链表无法倒着遍历,无法使用双指针技巧。
那么最简单的办法就是,把原始链表反转存入一条新的链表,然后比较这两条链表是否相同。
更聪明一些的办法是借助双指针算法:
- 1、先通过 双指针技巧 中的快慢指针来找到链表的中点:
- 2、如果 fast 指针没有指向 null,说明链表长度为奇数,slow 还要再前进一步:
- 3、从 slow 开始反转后面的链表,现在就可以开始比较回文串了:
class Solution {
public boolean isPalindrome(ListNode head) {
ListNode slow, fast;
slow = fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
if (fast != null)
slow = slow.next;
ListNode left = head;
ListNode right = reverse(slow);
while (right != null) {
if (left.val != right.val)
return false;
left = left.next;
right = right.next;
}
return true;
}
ListNode reverse(ListNode head) {
ListNode pre = null, cur = head;
while (cur != null) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
}