commit

王俊超 · 王俊超 · commit 74251ca76cb4 · 2018-10-09T13:06:54.000+08:00
diff --git a/.idea/misc.xml b/.idea/misc.xml
diff --git a/.idea/modules.xml b/.idea/modules.xml
diff --git a/【231】【Power of Two】/src/Solution.java b/【231】【Power of Two】/src/Solution.java
@@ -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;
+    }
+}
diff --git a/【231】【Power of Two】/src/Test.java b/【231】【Power of Two】/src/Test.java
@@ -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));
+    }
+}
diff --git a/【232】【Implement Queue using Stacks】/src/MyQueue.java b/【232】【Implement Queue using Stacks】/src/MyQueue.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();
+ */
diff --git a/【232】【Implement Queue using Stacks】/src/Test.java b/【232】【Implement Queue using Stacks】/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());
+    }
+}
diff --git a/【234】【Palindrome Linked List】/src/ListNode.java b/【234】【Palindrome Linked List】/src/ListNode.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;
+    }
+}
diff --git a/【234】【Palindrome Linked List】/src/Solution.java b/【234】【Palindrome Linked List】/src/Solution.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;
+    }
+}
diff --git a/【234】【Palindrome Linked List】/src/Solution2.java b/【234】【Palindrome Linked List】/src/Solution2.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;
+    }
+}
diff --git a/【234】【Palindrome Linked List】/src/Test.java b/【234】【Palindrome Linked List】/src/Test.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));
+    }
+}
diff --git a/【235】【Lowest Common Ancestor of a Binary Search Tree】/src/Solution.java b/【235】【Lowest Common Ancestor of a Binary Search Tree】/src/Solution.java
@@ -0,0 +1,56 @@
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Definition for a binary tree node.
+ * <pre>
+ * public class TreeNode {
+ *      int val;
+ *      TreeNode left;
+ *      TreeNode right;
+ *      TreeNode(int x) { val = x; }
+ * }
+ * </pre>
+ *
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:32
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+
+        List<TreeNode> pPath = new ArrayList<>();
+        List<TreeNode> qPath = new ArrayList<>();
+
+        search(pPath, root, p);
+        search(qPath, root, q);
+
+        TreeNode ancestor = pPath.get(0);
+
+        int idx = 1;
+        while (idx < pPath.size() && idx < qPath.size()) {
+            p = pPath.get(idx);
+            q = qPath.get(idx);
+            if (p != null && q != null && p.val == q.val) {
+                ancestor = pPath.get(idx);
+                idx++;
+            } else {
+                break;
+            }
+        }
+
+        return ancestor;
+    }
+
+    public void search(List<TreeNode> path, TreeNode root, TreeNode node) {
+        path.add(root);
+
+        if (root != null) {
+            if (root.val > node.val) {
+                search(path, root.left, node);
+            }
+            if (root.val < node.val) {
+                search(path, root.right, node);
+            }
+        }
+    }
+}
diff --git a/【235】【Lowest Common Ancestor of a Binary Search Tree】/src/TreeNode.java b/【235】【Lowest Common Ancestor of a Binary Search Tree】/src/TreeNode.java
@@ -0,0 +1,13 @@
+/**
+ * @author: wangjunchao(王俊超)
+ * @time: 2018-10-09 11:33
+ **/
+public class TreeNode {
+    int      val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode(int x) {
+        val = x;
+    }
+}
