solve problem Palindrome Linked List

Author: P-ppc

README.md

@@ -150,6 +150,7 @@ All solutions will be accepted!
 |111|[Minimum Depth Of Binary Tree](https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/description/)|[java/py/js](MinimumDepthOfBinaryTree)|Easy|
 |849|[Maximize Distance To Closest Person](https://leetcode-cn.com/problems/maximize-distance-to-closest-person/description/)|[java/py/js](./algorithms/MaximizeDistanceToClosestPerson)|Easy|
 |674|[Longest Continuous Increasing Subsequence](https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/description/)|[java/py/js](./algorithms/LongestContinuousIncreasingSubsequence)|Easy|
+|234|[Palindrome Linked List](https://leetcode-cn.com/problems/palindrome-linked-list/description/)|[java/py/js](./algorithms/PalindromeLinkedList)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/PalindromeLinkedList/README.md

@@ -0,0 +1,2 @@
+# Palindrome Linked List
+First get the length of linked list, then reverse the half of the linked list and compare two linked list

algorithms/PalindromeLinkedList/Solution.java

@@ -0,0 +1,44 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public boolean isPalindrome(ListNode head) {
+        int length = 0,
+            index = 0;
+        ListNode p = head;
+        
+        while (p != null) {
+            length++;
+            p = p.next;
+        }
+        
+        p = null;
+        
+        while (index < length / 2) {
+            index++;
+            ListNode temp = p;
+            p = head;
+            head = head.next;
+            p.next = temp;
+        }
+        
+        if (length % 2 == 1) {
+            head = head.next;
+        }
+        
+        while (p != null && head != null) {
+            if (p.val != head.val) {
+                return false;
+            } else {
+                p = p.next;
+                head = head.next;
+            }
+        }
+        return true;
+    }
+}

algorithms/PalindromeLinkedList/solution.js

@@ -0,0 +1,45 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var isPalindrome = function(head) {
+    let length = 0,
+        index = 0,
+        p = head
+    
+    while (p) {
+        length++
+        p = p.next
+    }
+    
+    p = null
+    
+    while (index < parseInt(length / 2)) {
+        index++
+        let temp = p
+        p = head
+        head = head.next
+        p.next = temp
+    }
+    
+    if (length % 2 === 1) {
+        head = head.next
+    }
+    
+    while (p && head) {
+        if (p.val !== head.val) {
+            return false
+        } else {
+            p = p.next
+            head = head.next
+        }
+    }
+    return true
+};

algorithms/PalindromeLinkedList/solution.py

@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def isPalindrome(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
+        length = 0
+        p = head
+        # get the length of linked list
+        while p:
+            length += 1
+            p = p.next
+        
+        # reverse the half of the linked list
+        index = 0
+        p = None
+        while index < length / 2:
+            index += 1
+            p, head, p.next = head, head.next, p
+            
+        if length % 2 == 1:
+            head = head.next
+            
+        # compare the two linked list
+        while p and head:
+            if p.val != head.val:
+                return False
+            else:
+                p = p.next
+                head = head.next
+        
+        return True
+