countPrime,minStack,MedianFinder,DeleteNodeInLinkedList

Author: jiangyong07

src/main/java/joshua/leetcode/design/MedianFinder.java

@@ -0,0 +1,102 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.design;
+
+import java.util.PriorityQueue;
+
+/**
+ * 295. Find Median from Data Stream<br/>
+ * <p/>
+ * <a href="https://leetcode.com/problems/find-median-from-data-stream/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class MedianFinder {
+
+    /**
+     * Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.
+     * <p/>
+     * Examples:
+     * [2,3,4] , the median is 3
+     * <p/>
+     * [2,3], the median is (2 + 3) / 2 = 2.5
+     * <p/>
+     * Design a data structure that supports the following two operations:<br/>
+     * <ul>
+     * <li>void addNum(int num) - Add a integer number from the data stream to the data structure.</li>
+     * <li>double findMedian() - Return the median of all elements so far.</li>
+     * </ul>
+     * For example:
+     * <p/>
+     * add(1)
+     * add(2)
+     * findMedian() -> 1.5
+     * add(3)
+     * findMedian() -> 2
+     */
+    // Adds a number into the data structure.
+    public abstract void addNum(int num);
+
+    // Returns the median of current data stream
+    public abstract double findMedian();
+
+
+    /**
+     * 先明确几个用到的概念：
+     *
+     * 最小堆(Min Heap), 内部实现是一个数组，每次插入堆会调整元素，保证最小元素在栈顶,即数组首位。每次调整的时间复杂度为o(logn)
+     * 最大堆(Max Heap), 保证最大元素在栈顶，其他同上。
+     *
+     * 本题思路是将data stream一分为二的存储在两个堆中，一个最小堆aHeap用于存储较大的一半元素，一个最大堆bHeap用于存储较小的一半元素。
+     * 并且保持aHeap永远比bHeap大小相等或者+1。
+     * 这样，如果两个堆大小相等，则median就是aHeap的栈顶元素和bHeap的栈顶元素的平均值；
+     * 如果两个堆大小相差1，则median就是aHeap的栈顶元素。
+     *
+     * 在Java中，PriorityQueue的内部实现就是min Heap。
+     * 这样PriorityQueue的头部对应min heap的栈顶。压入栈的操作等同于入队操作，优先队列会调整栈顶元素使其最小。
+     * 至于MaxHeap可以使用元素的负值插入到priorityQueue中，这样队列头部的元素的相反值就是最大值了，实现了max heap的作用。
+     *
+     */
+    public static class Solution1 extends MedianFinder {
+
+        /**
+         * store the larger half of the ascending stream.
+         * like [3,4,5] in [1,2,3,4,5]
+         */
+        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
+
+        /**
+         * store the lower half of the ascending stream,but in negative form, mimic the functionality of max heap.
+         * like [-2,-1] in [1,2,3,4,5]
+         */
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>();
+
+        /**
+         * mean the total number of data stream so far is even. initially it's even as zero.
+         */
+        private boolean isEven = true;
+
+        @Override
+        public void addNum(int num) {
+            minHeap.offer(num);
+            maxHeap.offer(-minHeap.poll());
+            /*if it's even before this adding action, even maxHeap's size will exceed minHeap after the above two
+            operations, then we need to get the largest element from the smaller part back into the larger part. */
+            if (isEven) {
+                minHeap.offer(-maxHeap.poll());
+            }
+            isEven = !isEven;
+        }
+
+        @Override
+        public double findMedian() {
+            if(minHeap.size() == 0)
+                return 0;
+            if (minHeap.size() == maxHeap.size()) {
+                return (minHeap.peek() - maxHeap.peek()) / 2.0;
+            } else {
+                return minHeap.peek();
+            }
+        }
+    }
+}

src/main/java/joshua/leetcode/hashtable/GroupAnagrams.java

@@ -47,6 +47,7 @@ public static class Solution1 extends GroupAnagrams{
         public List<List<String>> groupAnagrams(String[] strs) {
             Map<String, List<String>> anagrams = new HashMap<String, List<String>>();
             for (String str : strs) {
+                // flags用来作为anagram的hash key，例如"aab", "aba"的key都是“00...000012”，前面是24个零。
                 int[] flags = new int[26];
                 for(char ch : str.toCharArray()) {
                     flags[ch - 'a']++;

src/main/java/joshua/leetcode/linkedlist/DeleteNodeInLinkedList.java

@@ -0,0 +1,38 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.linkedlist;
+
+/**
+ * 237. Delete Node in a Linked List<br/>
+ * <p/>
+ * <a href="https://leetcode.com/problems/delete-node-in-a-linked-list/">leetcod link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class DeleteNodeInLinkedList {
+
+    /**
+     * Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
+     * <p/>
+     * Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3,
+     * <p/>
+     * the linked list should become 1 -> 2 -> 4 after calling your function.
+     *
+     * @param node the ndoe to delete from linked list
+     */
+    public abstract void deleteNode(ListNode node);
+
+    /**
+     * 采取复制值，不移动节点连接的方式来间接达到删除节点的结果。
+     */
+    public static class Solution1 extends DeleteNodeInLinkedList {
+
+        @Override
+        public void deleteNode(ListNode node) {
+            if (node == null || node.next == null)
+                return;
+            node.val = node.next.val;
+            node.next = node.next.next;
+        }
+    }
+}

src/main/java/joshua/leetcode/math/CountPrime.java

@@ -0,0 +1,50 @@
+// Copyright 2016 Baidu Inc. All rights reserved.
+
+package joshua.leetcode.math;
+
+/**
+ * 204. Count Primes<br/>
+ * <a href = "https://leetcode.com/problems/count-primes/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class CountPrime {
+
+    /**
+     * Count the number of prime numbers less than a non-negative number, n.
+     * <p/>
+     * Hint:
+     * <p/>
+     * Let's start with a isPrime function. To determine if a number is prime,
+     * we need to check if it is not divisible by any number less than n.
+     * <p/>
+     * The runtime complexity of isPrime function would be O(n) and hence counting the total prime numbers up to n would be O(n2).
+     * <p/>
+     * Could we do better?
+     * <p/>
+     * <p/>
+     * Show More Hint
+     *
+     * @param n
+     * @return
+     */
+    public abstract int countPrimes(int n);
+
+    public static class Solution extends CountPrime {
+
+        @Override
+        public int countPrimes(int n) {
+            boolean[] notPrime = new boolean[n];
+            int count = 0;
+            for(int i = 2; i < n; i++) {
+                if (!notPrime[i]) {
+                    count ++;
+                    for (int j = 2; i * j < n; j++) {
+                        notPrime[i * j] = true;
+                    }
+                }
+            }
+            return count;
+        }
+    }
+}

src/main/java/joshua/leetcode/stack/MinStack.java

@@ -3,50 +3,53 @@
 import java.util.Stack;
 
 /**
- * 
- * Design a stack that supports push, pop, top, 
+ * Design a stack that supports push, pop, top,
  * and retrieving the minimum element in constant time.
-
-	push(x) -- Push element x onto stack.
-	pop() -- Removes the element on top of the stack.
-	top() -- Get the top element.
-	getMin() -- Retrieve the minimum element in the stack.
-	
- * @author joy
+ * <p/>
+ * push(x) -- Push element x onto stack.
+ * pop() -- Removes the element on top of the stack.
+ * top() -- Get the top element.
+ * getMin() -- Retrieve the minimum element in the stack.
  *
+ * @author joy
  */
 public class MinStack {
-	
-	private Stack<Integer> mStack=new Stack<Integer>();
-	/**
-	 * minStack to store the minimum values in mStack.
-	 * each value in mStack means 'I'm the smallest to the bottom of mStack'.
-	 */
-	private Stack<Integer> minStack=new Stack<Integer>();
-	
+
+    /**
+     * 实际存储栈中的元素
+     */
+    private Stack<Integer> mStack = new Stack<Integer>();
+
+    /**
+     * minStack to store the minimum values about mStack.
+     * each value in mStack means 'I'm now the smallest amongst all current elements in mStack'.
+     */
+    private Stack<Integer> minStack = new Stack<Integer>();
+
     public void push(int x) {
         mStack.push(x);
-        if(minStack.isEmpty()){
-        	minStack.push(x);
-        }else{
-        	int top=minStack.peek();
-        	if(top>=x)
-        		minStack.push(x);
+        if (minStack.isEmpty()) {
+            minStack.push(x);
+        } else {
+            // 如果新元素比minStack的栈顶元素小，将新元素压入栈中，新元素就是当前mStack所有元素的最小值。
+            int top = minStack.peek();
+            if (top >= x)
+                minStack.push(x);
         }
-       
+
     }
 
     public void pop() {
-        int top=mStack.pop();
-        if(top==minStack.peek())
-        	minStack.pop();
+        int top = mStack.pop();
+        if (top == minStack.peek())
+            minStack.pop();
     }
 
     public int top() {
         return mStack.peek();
     }
 
     public int getMin() {
-    	return minStack.peek();
+        return minStack.peek();
     }
 }

src/test/java/joshua/leetcode/design/MedianFinderTest.java

@@ -0,0 +1,46 @@
+package joshua.leetcode.design;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+public class MedianFinderTest {
+
+    private static final double DELTA = 1e-15;
+    private List<Param> cases = Lists.newArrayList();
+
+    @Before
+    public void setUp() {
+        cases.add(new Param(6, 6));
+        cases.add(new Param(10, 8));
+        cases.add(new Param(2, 6));
+        cases.add(new Param(6, 6));
+        cases.add(new Param(5, 6));
+        cases.add(new Param(0, 5.5));
+    }
+
+    @Test
+    public void testSolution1() {
+        MedianFinder medianFinder = new MedianFinder.Solution1();
+        for (Param param : cases) {
+            medianFinder.addNum(param.add);
+            assertEquals(param.median, medianFinder.findMedian(), DELTA);
+        }
+    }
+
+    class Param {
+        int add;
+        double median;
+
+        public Param(int add, double median) {
+            this.add = add;
+            this.median = median;
+        }
+    }
+
+}

src/test/java/joshua/leetcode/math/CountPrimeTest.java

@@ -0,0 +1,15 @@
+package joshua.leetcode.math;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class CountPrimeTest {
+
+    @Test
+    public void testSolution1() {
+        CountPrime solution = new CountPrime.Solution();
+        assertEquals(25, solution.countPrimes(100));
+    }
+
+}