题目描述
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
进阶:
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?
//Definition for singly-linked list.
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
我的答案
不使用额外空间复杂度(适用于面试,笔试可直接用栈)
(1)快慢指针找中点 (2)右边的链表翻转(3)起点和中点一起开始比较 (4)恢复反转链表
//找到中间结点
public ListNode getMid(ListNode head){
ListNode slow = head;
ListNode fast = head;
//找中间结点需要记住的代码,偶数找的是偏前面的那个数
//while(fast.!=null&&fast.next!=null)则找的是偏后面那个数
while(fast.next!=null&&fast.next.next!=null){
fast = fast.next.next;
slow = slow.next;
}
return slow;
}
//反转链表
public ListNode reverse(ListNode head){
ListNode pre = null;
ListNode next = null;
ListNode cur = head;
while(cur!=null){
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
return pre;
}
//判断相等
public Boolean isEqual(ListNode n1,ListNode n2){
while(n1!=null&&n2!=null){
if(n1.val!=n2.val){
return false;
}
n1 = n1.next;
n2 = n2.next;
}
return true;
}
public boolean isPalindrome(ListNode head) {
ListNode mid = getMid(head);
//注意使用mid.next
ListNode right = reverse(mid.next);
ListNode n1 = head;
ListNode n2 = right; //注意不要改变这两个指针,下面的判断会改变指针
Boolean flag = isEqual(n1,n2);
ListNode node = reverse(right);
return flag;
}
官方解答
一共为两个步骤:
1.复制链表值到数组列表中。
2.使用双指针法判断是否为回文。
在编码的过程中,注意我们比较的是节点值的大小,而不是节点本身。正确的比较方式是:node_1.val == node_2.val,而 node_1 == node_2 是错误的。
class Solution {
public boolean isPalindrome(ListNode head) {
List<Integer> vals = new ArrayList<Integer>();
ListNode currentNode = head;
while(currentNode != null){
vals.add(currentNode.val);
currentNode = currentNode.next;
}
int front = 0;
int back = vals.size()-1;
while(front<back){
if(!vals.get(front).equals(vals.get(back))){
return false;
}
front++;
back--;
}
return true;
}
}
民间高手解答
fast走到末尾,slow刚好到中间。其中pre跟随slow,帮助prepre实现前半部分反转。
public boolean isPalindrome(ListNode head) {
if(head == null || head.next == null) {
return true;
}
ListNode slow = head, fast = head;
ListNode pre = head, prepre = null;
while(fast != null && fast.next != null) {
pre = slow;
slow = slow.next;
fast = fast.next.next;
pre.next = prepre;
prepre = pre;
}
if(fast != null) {
slow = slow.next;
}
while(pre != null && slow != null) {
if(pre.val != slow.val) {
return false;
}
pre = pre.next;
slow = slow.next;
}
return true;
}
用栈
class Solution {
public boolean isPalindrome(ListNode head) {
LinkedList<Integer> stack = new LinkedList<Integer>();
ListNode tmp = head;
while(tmp != null){
stack.push(tmp.val);
tmp = tmp.next;
} //先顺序压栈
ListNode tmp2 = head;
while(tmp2 != null){
if(tmp2.val != stack.pop()){//逆序出栈比较
return false;
}
tmp2 = tmp2.next;
}
return true;
}
}
转换为字符串,效率低下
class Solution {
public boolean isPalindrome(ListNode head) {
StringBuffer buffer = new StringBuffer();
while (head != null) {
buffer.append(head.val);
head = head.next;
}
return strIsPalindrome(buffer.toString());
}
public boolean strIsPalindrome(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;
}
}
剖析链表反转
public static Node reverseList(Node head) {
Node pre = null;
Node next = null;
while (head != null) {
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre; //返回pre而不是next
}
public static DoubleNode reverseList(DoubleNode head) {
DoubleNode pre = null;
DoubleNode next = null;
while (head != null) {
next = head.next;
head.next = pre;
head.last = next;
pre = head;
head = next;
}
return pre;
}