commit

Author: 王俊超

.idea/misc.xml

@@ -0,0 +1,28 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:24
+ **/
+public class Solution {
+    public boolean isPowerOfTwo(int n) {
+        if (n < 1) {
+            return false;
+        }
+
+        int remainder;
+        boolean result = false;
+        while (n > 0) {
+            // 求余数
+            remainder = n % 2;
+            n >>>= 1;
+
+            if (n == 0 && remainder == 1) {
+                result = true;
+                break;
+            } else if (n > 0 && remainder == 1) {
+                break;
+            }
+        }
+
+        return result;
+    }
+}

.idea/modules.xml

@@ -0,0 +1,16 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:28
+ **/
+public class Test {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        System.out.println(solution.isPowerOfTwo(-1));
+        System.out.println(solution.isPowerOfTwo(0));
+        System.out.println(solution.isPowerOfTwo(1));
+        System.out.println(solution.isPowerOfTwo(2));
+        System.out.println(solution.isPowerOfTwo(16));
+        System.out.println(solution.isPowerOfTwo(218));
+    }
+}

【231】【Power of Two】/src/Solution.java

@@ -0,0 +1,56 @@
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 09:37
+ **/
+class MyQueue {
+
+    private List<Integer>  list;
+
+    /**
+     * Initialize your data structure here.
+     */
+    public MyQueue() {
+        list = new LinkedList<>();
+    }
+
+    /**
+     * Push element x to the back of queue.
+     */
+    public void push(int x) {
+        list.add(x);
+    }
+
+    /**
+     * Removes the element from in front of queue and returns that element.
+     */
+    public int pop() {
+        return list.remove(0);
+    }
+
+    /**
+     * Get the front element.
+     */
+    public int peek() {
+        return list.get(0);
+    }
+
+    /**
+     * Returns whether the queue is empty.
+     */
+    public boolean empty() {
+        return list.isEmpty();
+    }
+}
+
+/**
+ * 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();
+ */

【231】【Power of Two】/src/Test.java

@@ -0,0 +1,15 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 10:58
+ **/
+public class Test {
+    public static void main(String[] args) {
+        MyQueue queue = new MyQueue();
+        queue.push(1);
+        queue.push(2);
+
+        System.out.println(queue.peek());
+        System.out.println(queue.pop());
+        System.out.println(queue.empty());
+    }
+}

【232】【Implement Queue using Stacks】/src/MyQueue.java

@@ -0,0 +1,12 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:03
+ **/
+public class ListNode {
+    int      val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+    }
+}

【232】【Implement Queue using Stacks】/src/Test.java

@@ -0,0 +1,58 @@
+/**
+ * O(n) time and O(1) space
+ * <pre>
+ * 1->2->2->1
+ * 1->2->3->2->1
+ * 先找到第二个2的位置，将2及后面的链逆转，形成新的链A，再按A与原来的链，从头开开始比较
+ * </pre>
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:02
+ **/
+public class Solution {
+    public boolean isPalindrome(ListNode head) {
+
+        // 没有节点或者只有一个结点
+        if (head == null || head.next == null) {
+            return true;
+        }
+
+        int count = 0;
+        ListNode node = head;
+        while (node != null) {
+            count++;
+            node = node.next;
+        }
+
+        // 找反向链的起始位置
+        count = (count + 1) / 2;
+        node = head;
+        while (count >0) {
+            count--;
+            node = node.next;
+        }
+
+
+        ListNode reverseHead = new ListNode(0);
+        ListNode temp;
+        while (node != null) {
+            temp = node.next;
+            node.next = reverseHead.next;
+            reverseHead.next = node;
+            node = temp;
+        }
+
+        reverseHead = reverseHead.next;
+
+        while (reverseHead != null) {
+            if (head.val != reverseHead.val) {
+                return false;
+            }
+
+            reverseHead = reverseHead.next;
+            head = head.next;
+        }
+
+        return true;
+    }
+}

【234】【Palindrome Linked List】/src/ListNode.java

@@ -0,0 +1,38 @@
+/**
+ * O(n) time and O(n) space
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:02
+ **/
+public class Solution2 {
+    public boolean isPalindrome(ListNode head) {
+
+        if (head == null) {
+            return true;
+        }
+
+        // 反向链的头
+        ListNode reverseHead = new ListNode(-1);
+
+        ListNode temp = head;
+        ListNode node;
+        // 头插法构建反向链
+        while (temp != null) {
+            node = new ListNode(temp.val);
+            node.next = reverseHead.next;
+            reverseHead.next = node;
+            temp = temp.next;
+        }
+
+        reverseHead = reverseHead.next;
+        while (head != null) {
+            if (head.val != reverseHead.val) {
+                return false;
+            }
+
+            head = head.next;
+            reverseHead = reverseHead.next;
+        }
+        return true;
+    }
+}

【234】【Palindrome Linked List】/src/Solution.java

@@ -0,0 +1,42 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:10
+ **/
+public class Test {
+    public static void main(String[] args) {
+        test1();
+        test2();
+        test3();
+    }
+
+    public static void test1() {
+        Solution solution = new Solution();
+        ListNode head = new ListNode(1);
+        head.next = new ListNode(2);
+        System.out.println(solution.isPalindrome(head));
+    }
+
+    public static void test2() {
+        Solution solution = new Solution();
+
+        ListNode head = new ListNode(1);
+        head.next = new ListNode(2);
+        head.next.next= new ListNode(2);
+        head.next.next.next= new ListNode(1);
+        head.next.next.next.next= new ListNode(2);
+        head.next.next.next.next.next= new ListNode(2);
+        head.next.next.next.next.next.next= new ListNode(1);
+        System.out.println(solution.isPalindrome(head));
+    }
+
+    public static void test3() {
+        Solution solution = new Solution();
+
+        ListNode head = new ListNode(1);
+        head.next = new ListNode(2);
+        head.next.next= new ListNode(2);
+        head.next.next.next= new ListNode(1);
+
+        System.out.println(solution.isPalindrome(head));
+    }
+}