refactor 234

Author: fishercoder1534

README.md

@@ -384,7 +384,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |237|[Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_237.java)| O(1)|O(1) | Easy| LinkedList
 |236|[Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_236.java)| O(n)|O(h) | Medium| DFS
 |235|[Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_235.java)| O(h)|O(1) | Easy| DFS
-|234|[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_234.java)| O(n)|O(1) | Easy| 
+|234|[Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_234.java)| O(n)|O(1) | Easy| Linked List 
 |233|[Number of Digit One](https://leetcode.com/problems/number-of-digit-one/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_233.java)| O(n)|O(1) | Hard| Math
 |232|[Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_232.java)| O(n)|O(n) | Medium| Stack, Design
 |231|[Power of Two](https://leetcode.com/problems/power-of-two/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_231.java)| O(1)|O(1) | Easy| 

src/main/java/com/fishercoder/solutions/_234.java

@@ -1,95 +1,84 @@
 package com.fishercoder.solutions;
 
 import com.fishercoder.common.classes.ListNode;
-import com.fishercoder.common.utils.CommonUtils;
 
-import java.util.Stack;
+import java.util.ArrayList;
+import java.util.List;
 
-/**Given a singly linked list, determine if it is a palindrome.
+/**
+ * 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?*/
+ Could you do it in O(n) time and O(1) space?
+ */
+
 public class _234 {
-    //then I turned to Discuss, and found that they actually reverse the half and then do the comparison, e.g. https://discuss.leetcode.com/topic/33376/java-easy-to-understand
-    //a strong candidate would try to restore the reversed half before return to keep the input intact
-    //practice does make perfect! Cheers! I implemented this code in 20 mins this time! Cheers!
-    public boolean isPalindrome_O1_space(ListNode head) {
-        if(head == null) return true;
-        //how to get to middle node in a list? a typical trick is to use slow/fast pointers, when fast reaches the end, slow arrives at the middle
-        ListNode slow = head, fast = head;
-        while(fast.next != null && fast.next.next != null){
-            fast = fast.next.next;
-            slow = slow.next;
-        }
-        //if we exit due to fast.next == null, that means the length of this list is odd, 
-        //if it's due to fast.next.next == null, then it's even
-        //actually it doesn't matter whether the length if odd or even, we'll always use slow as the newHead to reverse the second half
-        ListNode reversedHead = reverse(slow.next);
-        CommonUtils.printList(reversedHead);
-        CommonUtils.printList(head);
-        ListNode firstHalfHead = head;
-        while(firstHalfHead != null && reversedHead != null){
-            if(firstHalfHead.val != reversedHead.val) return false;
-            firstHalfHead = firstHalfHead.next;
-            reversedHead = reversedHead.next;
+    public static class Solution1 {
+        /**O(n) time
+         * O(1) space
+         * */
+        public boolean isPalindrome(ListNode head) {
+            if (head == null) return true;
+
+            ListNode slow = head, fast = head;
+            while (fast.next != null && fast.next.next != null) {
+                fast = fast.next.next;
+                slow = slow.next;
+            }
+
+            ListNode reversedHead = reverse(slow.next);
+            ListNode firstHalfHead = head;
+            while (firstHalfHead != null && reversedHead != null) {
+                if (firstHalfHead.val != reversedHead.val) return false;
+                firstHalfHead = firstHalfHead.next;
+                reversedHead = reversedHead.next;
+            }
+            return true;
         }
-        return true;
-    }
-    
-    private ListNode reverse(ListNode head) {
-        ListNode pre = null;
-        while(head != null){
-            ListNode next = head.next;
-            head.next = pre;
-            pre = head;
-            head = next;
+
+        private ListNode reverse(ListNode head) {
+            ListNode pre = null;
+            while (head != null) {
+                ListNode next = head.next;
+                head.next = pre;
+                pre = head;
+                head = next;
+            }
+            return pre;
         }
-        return pre;
     }
 
-    //I could only think of solutions that use O(n) space: store half of the nodes values
-    //I don't know how Two Pointers technique could achieve O(1) effect
-    public boolean isPalindrome(ListNode head) {
-        //let's get it AC'ed first
-        //truely, I got this one AC'ed the first time I submitted it, cheers!
-        
-        //get the length of the list first
-        ListNode temp = head;
-        int count = 0;
-        while(temp != null){
-            count++;
-            temp = temp.next;
-        }
-        boolean lengthIsEven = (count%2 == 0);
-        Stack<Integer> stack = new Stack();
-        temp = head;
-        for(int i = 0; i < count/2; i++){
-            stack.push(temp.val);
-            temp = temp.next;
+    public static class Solution2 {
+        /**O(n) time
+         * O(n) space
+         * */
+        public boolean isPalindrome(ListNode head) {
+            int len = 0;
+            ListNode fast = head;
+            ListNode slow = head;
+            List<Integer> firstHalf = new ArrayList<>();
+            while (fast != null && fast.next != null) {
+                fast = fast.next.next;
+                firstHalf.add(slow.val);
+                slow = slow.next;
+                len += 2;
+            }
+            if (fast != null) {
+                len++;
+            }
+            if (len % 2 != 0) {
+                slow = slow.next;
+            }
+            int i = firstHalf.size() - 1;
+            while (slow != null) {
+                if (firstHalf.get(i--) != slow.val) {
+                    return false;
+                }
+                slow = slow.next;
+            }
+            return true;
         }
-        
-        if(!lengthIsEven) temp = temp.next;
-        while(!stack.isEmpty()){
-            if(stack.pop() != temp.val) return false;
-            temp = temp.next;
-        }
-        return true;
-    }
-    
-    public static void main(String...strings){
-        _234 test = new _234();
-//        ListNode head = new ListNode(1);
-//        head.next = new ListNode(2);
-//        head.next.next = new ListNode(3);
-//        head.next.next.next = new ListNode(4);
-//        head.next.next.next.next = new ListNode(5);
-        
-        ListNode head = new ListNode(1);
-        CommonUtils.printList(head);
-//        ListNode result = test.reverseList_iterative(head);
-//        Boolean result = test.isPalindrome(head);
-        Boolean result = test.isPalindrome_O1_space(head);
-        System.out.println(result);
     }
 
 }

src/test/java/com/fishercoder/_234Test.java

@@ -0,0 +1,40 @@
+package com.fishercoder;
+
+import com.fishercoder.common.classes.ListNode;
+import com.fishercoder.common.utils.LinkedListUtils;
+import com.fishercoder.solutions._234;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _234Test {
+    private static _234.Solution1 solution1;
+    private static _234.Solution2 solution2;
+    private static ListNode head;
+
+    @BeforeClass
+    public static void setup(){
+        solution1 = new _234.Solution1();
+        solution2 = new _234.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        head = LinkedListUtils.contructLinkedList(new int[]{1,2,3,2,1});
+        assertEquals(true, solution1.isPalindrome(head));
+
+        head = LinkedListUtils.contructLinkedList(new int[]{1,2,3,2,1});
+        assertEquals(true, solution2.isPalindrome(head));
+    }
+
+    @Test
+    public void test2() {
+        head = LinkedListUtils.contructLinkedList(new int[]{1,2,2,1});
+        assertEquals(true, solution1.isPalindrome(head));
+
+        head = LinkedListUtils.contructLinkedList(new int[]{1,2,3,2,1});
+        assertEquals(true, solution2.isPalindrome(head));
+    }
+
+}