[Function add]

1. Add leetcode solutions.

Author: Botao Xiao

README.md

@@ -407,6 +407,10 @@
 
 [231. Power of Two](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/231.%20Power%20of%20Two.md)
 
+[232. Implement Queue using Stacks](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/232.%20Implement%20Queue%20using%20Stacks.md)
+
+[234. Palindrome Linked List](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/234.%20Palindrome%20Linked%20List.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/232. Implement Queue using Stacks.md

@@ -115,4 +115,62 @@ class MyQueue {
  * int param_3 = obj.peek();
  * boolean param_4 = obj.empty();
  */
-```
+```
+
+### 二刷
+1. Implement the queue using two stacks.
+2. We have a stack for save values and another one for temperory saving, when we want to use peek or poll, we pop all values saved in one stack to another and read(or pop) the peek values at the top of another stack. After we finished the action, we need to pop the values back to the original stack.
+```Java
+class MyQueue {
+    Stack<Integer> save = null;
+    Stack<Integer> temp = null;
+    /** Initialize your data structure here. */
+    public MyQueue() {
+        this.save = new Stack<>();
+        this.temp = new Stack<>();
+    }
+
+    /** Push element x to the back of queue. */
+    public void push(int x) {
+        this.save.push(x);
+    }
+
+    /** Removes the element from in front of queue and returns that element. */
+    public int pop() {
+        while(!this.save.empty()){
+            this.temp.push(this.save.pop());
+        }
+        int result = this.temp.pop();
+        while(!this.temp.empty()){
+            this.save.push(this.temp.pop());
+        }
+        return result;
+    }
+
+    /** Get the front element. */
+    public int peek() {
+        while(!this.save.empty()){
+            this.temp.push(this.save.pop());
+        }
+        int result = this.temp.peek();
+        while(!this.temp.empty()){
+            this.save.push(this.temp.pop());
+        }
+        return result;
+    }
+
+    /** Returns whether the queue is empty. */
+    public boolean empty() {
+        return this.save.empty();
+    }
+}
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue obj = new MyQueue();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.peek();
+ * boolean param_4 = obj.empty();
+ */
+```

leetcode/234. Palindrome Linked List.md

@@ -56,4 +56,81 @@ class Solution {
         return true;
     }
 }
-```
+```
+
+### 二刷
+1. Method 1: I first save the list as array and then checked the palindrome of the array.
+```Java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public boolean isPalindrome(ListNode head) {
+        ListNode cur = head;
+        List<Integer> temp = new LinkedList<>();
+        while(cur != null){
+            temp.add(cur.val);
+            cur = cur.next;
+        }
+        Integer[] arr = new Integer[temp.size()];
+        for(int i = 0; i < temp.size(); i++){
+            arr[i] = (Integer)temp.get(i);
+        }
+        int start = 0, end = arr.length - 1;
+        while(start < end){
+            if(!arr[start++].equals(arr[end--])){
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+2. Method 2, I reversed the first half of the list, and compare the first half and second half.
+```Java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public boolean isPalindrome(ListNode head) {
+        if(head == null) return true;
+        ListNode dummy = new ListNode(0);;
+        dummy.next = head;
+        ListNode slow = dummy;
+        ListNode fast = dummy;
+        while(fast != null && fast.next != null){
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode temp = slow.next;
+        slow.next = null;
+        ListNode pre = null;
+        ListNode cur = head;
+        ListNode next = null;
+        while(cur != null){
+            next = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = next;
+        }
+        cur = fast == null ? pre.next : pre;
+        while(cur != null && temp != null){
+            if(cur.val != temp.val) return false;
+            cur = cur.next;
+            temp = temp.next;
+        }
+        return true;
+    }
+}
+```