LeetCode234、回文链表——（多方法实现）

1、题目描述

2、解法

2.1、使用额外的链表来存储，比较两个链表

比较简单，但是效率也比较慢。时间复杂度O（n），空间复杂度O（n）；

2.2、模拟树的后序遍历，利用递归

/**
 * 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; }
 * }
 */
class Solution {
     //定义一个指针记录头结点
    ListNode left = null;
    public boolean isPalindrome(ListNode head) {
        if(head==null||head.next==null){
            return true;
        }
        //定义一个指针记录头结点
         left = head;
        //反序遍历head
        return traverse(head);
    }
    private 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)，空间复杂度O（n）；

2.3、解法三：链表部分反转，双判断回文

/**
 * 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; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null){
            return true;
        }
 //1、查找中心的结点，如果是奇数，结点仅一个，偶数则两个
        ListNode slow=head,fast=head;//使用快慢指针，每次slow走一步、fast走两步,n次就是slow——n，fast——2n
        while(fast!=null && fast.next !=null ){//一直走
            slow = slow.next;
            fast = fast.next.next;
        }
        if(fast != null){//奇数
            slow = slow.next;
        }
        //反转slow之后的链表
        ListNode last = reverse(slow);


        //比较两端链表
        while(last!=null){//从反转的链表比较
            if(head.val!=last.val){
                return false;
            }
            head = head.next;
            last = last.next;
        }
        return true;

    }
    public ListNode reverse(ListNode head){
        if(head==null||head.next==null) return head;
        ListNode last = reverse(head.next);//逆序下一部分
        //同时链接当前的结点
        head.next.next = head;
        head.next = null;//释放
        return last;
    }   
}

复杂度同上。

2.4、解法四、将反转链表的方法使用为迭代（破坏链表原有结构）

   public ListNode reverse(ListNode head){
        ListNode pre = null,cur=head,next=head;
        while(cur!=null){
            next = cur.next;
            cur.next = pre;//反转
            //进行下一个结点的反转
            pre = cur;
            cur = next;
        }
        return pre;
    }

时间复杂度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; }
 * }
 */
class Solution {
      //为了恢复链表结构，记录的指针-------------------------------------------
     ListNode start=null,end=null;
    public boolean isPalindrome(ListNode head) {
        if(head==null){
            return true;
        }
 //1、查找中心的结点，如果是奇数，结点仅一个，偶数则两个
        ListNode slow=head,fast=head;//使用快慢指针，每次slow走一步、fast走两步,n次就是slow——n，fast——2n
      
       
        while(fast!=null && fast.next !=null ){//一直走
            start = slow;//start一直位于slow的上一个结点------------
            slow = slow.next;
            fast = fast.next.next;
           
        }
        if(fast != null){//奇数
            start = slow;//start一直位于slow的上一个结点-------------
            slow = slow.next;
        }
       
        //反转slow之后的链表
        ListNode last = reverse(slow);

        end = last;//记录逆序头结点-------------


        //比较两端链表
        while(last!=null){//从反转的链表比较
            if(head.val!=last.val){
                return false;
            }
            head = head.next;
            last = last.next;
        }

    //恢复结构-----------
        start.next =  reverse(end);;---------
        //试着打印一手：
      //  while(start!=null){
       //     System.out.println(start.val);
       //     start = start.next;
       // }
        return true;

    }
    public ListNode reverse(ListNode head){
        ListNode pre = null,cur=head,next=head;
        while(cur!=null){
            next = cur.next;
            cur.next = pre;//反转
            //进行下一个结点的反转
            pre = cur;
            cur = next;
        }
        return pre;
    }

   
}