LeetCode 234. Palindrome Linked List

Given a singly linked list, determine if it is a palindrome.

Follow up: Could you do it in O(n) time and O(1) space?

 

Solution 1 (loop through and use two-pointer O(n) time and O(n) space)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public bool IsPalindrome(ListNode head) {
        if(head==null||head.next ==null)
        {
            return true;
        }
        List<int> list = new List<int>();
        ListNode node = head;
        while(node!=null)
        {
            list.Add(node.val);
            node=node.next;
        }
        int l = list.Count();
        int p1=0; int p2=l-1;
        while(p1<=p2)
        {
            if(list[p1]==list[p2])
            {
                p1++;
                p2--;
            }
            else
            {
                return false;
            }
        }
        return true;
        
        
    }
}

 

Follow up/ Solution 2

Find the Middle node (two-pointer one fast one slow)

Then reverse the middle.next

Compare reversed  to head until reversed==null

public class Solution {
    public bool IsPalindrome(ListNode head) {
        if(head==null||head.next ==null)
        {
            return true;
        }
        //Find the lower part from the list started from the middle.mext;
        ListNode lower = FindMiddleNode(head).next;
        //reverse lower to compare with the upper part
        ListNode reversedLower = Reverse(lower);
        while(reversedLower!=null)
        {
            if(reversedLower.val == head.val)
            {
                reversedLower = reversedLower.next;
                head = head.next;
            }
            else
            {
                return false;
            }
        }
        return true;
    }
    
    private ListNode FindMiddleNode(ListNode head)
    {
        ListNode slow = head;
        //one step faster so middle for even is n/2
        ListNode fast = head.next;
        while(fast!=null && fast.next!=null)
        {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
    private ListNode Reverse(ListNode list)
    {
        if(list==null ||list.next == null)
        {
            return list;
        }
        ListNode prev = null;
        while(list!=null)
        {
            ListNode temp = list.next;
            list.next = prev;
            prev= list;
            list = temp;
        }
        return prev;
    }
}