1、题目描述![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/f7f99db9ceb24fbd63b5e02068dd4658.png)
额外要求:你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?
2、题解
2.1 解题思路1
使用额外的栈空间,先将链表中所有的元素依次压入栈中,得到链表的逆序,然后将栈中的元素依次弹出和链表中的元素从头到尾依次比较,如果发现不相等的元素,说明该链表不是回文链表,如果直到栈空,也没发现不相等的元素,那么该链表是回文链表。
public static boolean isHuiWen01(ListNode head) {
if (head == null) {
return true;
}
Stack<Integer> stack = new Stack<>();
ListNode cur = head;
while (cur != null) {
stack.push(cur.val);
cur = cur.next;
}
while (!stack.isEmpty()) {
if (stack.pop() != head.val) {
return false;
}
head = head.next;
}
return true;
}
这种思路,时间复杂度O(N),空间复杂度O(N)。
2.2 解题思路2
思路2也是逆序比较的想法,通过观察可以得出,只需要将链表的后半部分元素逆序,然后和前半部分依次比较就可以得出链表是否是回文了。因此思路2和思路1的不同在于:
- 先找到链表的中点或者下中点,然后从中点(下中点)处依次将剩下的元素压入栈中。
- 依次弹出栈中元素和前半部分的链表元素依次比较,即可。
public static boolean isHuiWen02(ListNode head) {
if (head == null) {
return true;
}
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
}
Stack<Integer> stack = new Stack<>();
while (slow != null) {
stack.push(slow.val);
slow = slow.next;
}
while (!stack.isEmpty()) {
if (stack.pop() != head.val) {
return false;
}
head = head.next;
}
return true;
}
思路2的时间复杂度依然是O(N),空间复杂度也是O(N),但是系数是思路1的一半,减少了一半的栈空间。
2.3 解题思路3
思路3在思路2的基础上,去掉了栈,采用原地反转后半部分链表的思路,然后依次比较前半部分和后半部分的元素是否相等,具体来说:
- 首先找到链表的中点或者上中点mid,如何寻找链表中点可以参考这篇文章
- 然后将mid.next及后面的链表部分反转,同时将mid.next设置为null,这样单链表就变为了如下形式
1->2->3->4->null
1->2->null
4->3->null
- 依次遍历两个链表,如果在遍历过程中,发现了不等元素,说明链表不是回文,否则是回文
public static boolean isHuiWen03(ListNode head) {
if (head == null) {
return true;
}
ListNode fast = head;
ListNode slow = head;
while (fast.next != null && fast.next.next != null) {
fast = fast.next.next;
slow = slow.next;
}
// 此时slow来到中点或者上中点的位置
ListNode slowPre = slow;
slow = slow.next;
slowPre.next = null;
slow = reverse(slow);
ListNode cur = slow;
while (cur != null && head != null) {
if (cur.val != head.val) {
return false;
}
cur = cur.next;
head = head.next;
}
slowPre.next = reverse(slow);
return true;
}
private static ListNode reverse(ListNode head) {
ListNode next = null;
ListNode pre = null;
while (head != null) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
这种时间复杂度是O(N),空间复杂度是O(1),因为是原地反转链表
3、提交结果
下面是最后一种的提交结果,当然可以选择最后不复原链表,时间会更好一些