slidingWindowMaximum, Search2DMatrix, ReserseWord2

Author: jiangyong07

src/main/java/joshua/leetcode/bits/ReverseBits.java

@@ -2,47 +2,47 @@
 
 public class ReverseBits {
 
-	/**
-	 * Reverse bits of a given 32 bits unsigned integer.
-	   For example, given input 43261596 (represented in binary as 00000010100101000001111010011100), 
-	   return 964176192   (represented in binary as 00111001011110000010100101000000).
-	   
-	 */
+    /**
+     * Reverse bits of a given 32 bits unsigned integer.
+     * For example, given input 43261596 (represented in binary as 00000010100101000001111010011100),
+     * return 964176192   (represented in binary as 00111001011110000010100101000000).
+     */
 
-	// you need treat n as an unsigned value
-	public int reverseBits(int n) {
-		if(n==1)
-			return Integer.MIN_VALUE;
-		String bitStr = Integer.toBinaryString(n);
-		StringBuilder sBuilder = new StringBuilder();
-		for (int i = bitStr.length() - 1; i > -1; i--) {
-			sBuilder.append(bitStr.substring(i, i + 1));
-		}
-		for (int j = 1; j <= 32 - bitStr.length(); j++)
-			sBuilder.append("0");
-		String outStr=sBuilder.toString();
-		if(outStr.startsWith("0"))
-			return Integer.parseInt(outStr, 2);
-		sBuilder=new StringBuilder();
-		sBuilder.append(0);
-		for (int i = 1; i <32; i++) {
-			sBuilder.append(outStr.substring(i, i + 1).endsWith("0")?"1":"0");
-		}
-		return 0-(Integer.parseInt(sBuilder.toString().trim(), 2)+1);
-	}
-	
-	/**
-	 * Parse 32-bit string into signed integer
-	 * @return
-	 */
-	public static int parseFromBitStr(String bitStr){
-		if(bitStr.startsWith("0"))
-				return Integer.parseInt(bitStr, 2);
-		StringBuilder sBuilder=new StringBuilder();
-		sBuilder.append(0);
-		for (int i = 1; i <32; i++) {
-			sBuilder.append(bitStr.substring(i, i + 1)=="0"?"1":"0");
-		}
-		return 0-(Integer.parseInt(sBuilder.toString().trim(), 2)+1);	
-	}
+    // you need treat n as an unsigned value
+    public int reverseBits(int n) {
+        if (n == 1)
+            return Integer.MIN_VALUE;
+        String bitStr = Integer.toBinaryString(n);
+        StringBuilder sBuilder = new StringBuilder();
+        for (int i = bitStr.length() - 1; i > -1; i--) {
+            sBuilder.append(bitStr.substring(i, i + 1));
+        }
+        for (int j = 1; j <= 32 - bitStr.length(); j++)
+            sBuilder.append("0");
+        String outStr = sBuilder.toString();
+        if (outStr.startsWith("0"))
+            return Integer.parseInt(outStr, 2);
+        sBuilder = new StringBuilder();
+        sBuilder.append(0);
+        for (int i = 1; i < 32; i++) {
+            sBuilder.append(outStr.substring(i, i + 1).endsWith("0") ? "1" : "0");
+        }
+        return 0 - (Integer.parseInt(sBuilder.toString().trim(), 2) + 1);
+    }
+
+    /**
+     * Parse 32-bit string into signed integer
+     *
+     * @return
+     */
+    public static int parseFromBitStr(String bitStr) {
+        if (bitStr.startsWith("0"))
+            return Integer.parseInt(bitStr, 2);
+        StringBuilder sBuilder = new StringBuilder();
+        sBuilder.append(0);
+        for (int i = 1; i < 32; i++) {
+            sBuilder.append(bitStr.substring(i, i + 1) == "0" ? "1" : "0");
+        }
+        return 0 - (Integer.parseInt(sBuilder.toString().trim(), 2) + 1);
+    }
 }

src/main/java/joshua/leetcode/divideconquer/Search2DMatrixII.java

@@ -34,15 +34,35 @@ public abstract class Search2DMatrixII {
     public abstract boolean searchMatrix(int[][] matrix, int target);
 
     /**
-     *  观察矩阵可以发现， 每个对角线上的元素matrix[i,i]都大于所有其他index小于i的元素，即该元素的左上角的矩阵。
-     *  因此可以先对对角线上元素做二分查找。
+     *  观察矩阵可以发现， 斜对角线上的每个元素matrix[i,j]都是对应的列的最小元素，是对应的行的最大元素。
+     *  因此可以比较斜对角线上的最右上角元素ele和target的大小关系：
+     *  如果ele > target, 可以过滤掉ele对应的行
+     *  如果ele < target, 可以过滤掉ele对应的列
+     *  如果相等可以直接返回。
+     *
+     *  这样每次比较都可以过滤掉一行，或者一列，总的时间复杂度就是o(m+n)
      *
      */
     public static class Solution1 extends Search2DMatrixII {
 
         @Override
         public boolean searchMatrix(int[][] matrix, int target) {
-
+            if(matrix == null || matrix[0] == null || matrix[0].length == 0) {
+                return false;
+            }
+            int row = matrix.length, col = matrix[0].length;
+            int i = 0, j = col - 1;
+            while(i < row && j > -1) {
+                int ele = matrix[i][j];
+                if (ele < target) {
+                    i++;
+                } else if (ele > target) {
+                    j--;
+                } else {
+                    return true;
+                }
+            }
+            return false;
         }
     }
 }

src/main/java/joshua/leetcode/heap/SlidingWindowMaximum.java

@@ -0,0 +1,135 @@
+package joshua.leetcode.heap;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * 239. Sliding Window Maximum<br/>
+ * <p/>
+ * <a href="https://leetcode.com/problems/sliding-window-maximum/">leetcode link</a>
+ *
+ * @author Jiang Yong ([email protected])
+ */
+public abstract class SlidingWindowMaximum {
+
+    /**
+     * Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.
+     * <p/>
+     * For example,
+     * Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.
+     * <p/>
+     * Window position                Max
+     * ---------------               -----
+     * [1  3  -1] -3  5  3  6  7       3
+     * 1 [3  -1  -3] 5  3  6  7        3
+     * 1  3 [-1  -3  5] 3  6  7        5
+     * 1  3  -1 [-3  5  3] 6  7        5
+     * 1  3  -1  -3 [5  3  6] 7        6
+     * 1  3  -1  -3  5 [3  6  7]       7
+     * Therefore, return the max sliding window as [3,3,5,5,6,7].
+     * <p/>
+     * Note:
+     * You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.
+     * <p/>
+     * Follow up:
+     * Could you solve it in linear time?
+     */
+    public abstract int[] maxSlidingWindow(int[] nums, int k);
+
+
+    /**
+     * 使用双端队列（Deque）.
+     * 使用双端队列的原因是一要保持队列内的元素保持元素的本来顺序，同时提供了类似Stack的操作可以在插入
+     * 端删除元素。
+     */
+    public static class Solution1 extends SlidingWindowMaximum {
+
+        @Override
+        public int[] maxSlidingWindow(int[] nums, int k) {
+            // store the index other than value
+            Deque<Integer> deque = new ArrayDeque<Integer>();
+            // store the maximum of all windows, 1 <=k <= nums.length
+            int[] result = new int[nums.length - k + 1];
+            for (int i = 0; i < nums.length; i++) {
+
+                //step 1. remove all elements with index smaller than i-k+1 from the
+                //head of the deque, 'cause they are left out of the siding window
+                while (!deque.isEmpty() && deque.peek() < i - k + 1) {
+                    //remove from the head of the deque, poll() equals pollFirst()
+                    deque.poll();
+                }
+
+                //step 2: examine the element from the tail of deque, pop it if it's smaller than
+                //nums[i], cause for elements smaller than nums[i], they won't have
+                //a chance to become the maximum in the sliding window.
+                while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
+                    deque.pollLast();
+                }
+
+                //step 3: put the new index into the tail of the deque by offer() method
+                deque.offer(i);
+
+                //step 4: for every i larger than k-1, calculate the maximum element of sliding
+                //window represented by [i-k+1, i]
+                if (i >= k - 1) {
+                    result[i - k + 1] = nums[deque.peek()];
+                }
+            }
+            return result;
+        }
+    }
+
+    /**
+     * For Example: nums = [2,1,3,4,6,3,8,9,10,12,56], w=4
+     * <p/>
+     * partition the array in blocks of size w=4. The last block may have less then w. 2, 1, 3, 4 | 6, 3, 8, 9 | 10, 12, 56|
+     * <p/>
+     * Traverse the list from start to end and calculate max so far. Reset max after each block boundary (of w
+     * elements).
+     * left_max[] = 2, 2, 3, 4 | 6, 6, 8, 9 | 10, 12, 56
+     * <p/>
+     * Similarly calculate max in future by traversing from end to start.
+     * right_max[] = 4, 4, 4, 4 | 9, 9, 9, 9 | 56, 56, 56
+     * <p/>
+     * now, sliding max at each position i in current window, sliding-max(i) = max{rightmax(i), leftmax(i+w-1)}
+     *
+     * sliding_max = 4, 6, 6, 8, 9, 10, 12, 56
+     * <p/>
+     *
+     * <a href = "https://leetcode.com/discuss/62695/o-n-solution-in-java-with-two-simple-pass-in-the-array">leetcode
+     * 讨论解法链接</a>
+     */
+    public static class Solution2 extends SlidingWindowMaximum {
+
+        @Override
+        public int[] maxSlidingWindow(int[] nums, int k) {
+            if(nums == null || nums.length == 0) {
+                return new int[]{};
+            }
+
+            /*for each window, maximum element from left to right*/
+            int[] max_left = new int[nums.length];
+            /*for each window, maximum element from right to left*/
+            int[] max_right = new int[nums.length];
+
+            max_left[0] = nums[0];
+            max_right[nums.length - 1] = nums[nums.length - 1];
+
+            for (int i = 1; i < nums.length; i++) {
+                max_left[i] = (i % k == 0) ? nums[i] : Math.max(max_left[i - 1], nums[i]);
+
+                final int j = nums.length - i - 1;
+                max_right[j] = (j % k == 0) ? nums[j] : Math.max(max_right[j + 1], nums[j]);
+            }
+
+            // having nums.length-k+1 windows in the nums array
+            int[] sliding_max = new int[nums.length - k + 1];
+
+            for (int i = 0; i + k <= nums.length; i++) {
+                sliding_max[i] = Math.max(max_right[i], max_left[i + k - 1]);
+            }
+
+            return sliding_max;
+        }
+    }
+}

src/main/java/joshua/leetcode/heap/TopKFrequentElements.java

@@ -65,6 +65,10 @@ public List<Integer> topKFrequent(int[] nums, int k) {
             Arrays.sort(nums);
             Map<Integer, List<Integer>> frequencyBucket = new HashMap<Integer, List<Integer>>();
             int maxFrequency = 0;
+            /**
+             * 记录下每个number的frequency,相同frequency的numer是存储在同一个key下面的，key就是frequency的值，
+             * 同时记录下最大的frequency.
+             */
             for (int i = 0; i < nums.length; i++) {
                 int count = 1;
                 while (i + 1 < nums.length && nums[i] == nums[i + 1]) {
@@ -79,6 +83,9 @@ public List<Integer> topKFrequent(int[] nums, int k) {
             }
             List<Integer> topK = new ArrayList<Integer>();
             int size = 0;
+            /**
+             * 从maxFrequency递减查找frequencyBucket
+             */
             for (int i = maxFrequency; i > 0; i--) {
                 if (!frequencyBucket.containsKey(i)) {
                     continue;

src/main/java/joshua/leetcode/strings/LongestCommonPrefix.java

@@ -2,53 +2,53 @@
 
 /**
  * 14	Longest Common Prefix
- * @see <a href="https://leetcode.com/problems/longest-common-prefix/">leetcode link</a>
- * @author joy
  *
+ * @author joy
+ * @see <a href="https://leetcode.com/problems/longest-common-prefix/">leetcode link</a>
  */
 public abstract class LongestCommonPrefix {
 
-	/**
-	 * Write a function to find the longest common prefix string amongst an array of strings.
-	 * 
-	 * @param strs
-	 * @return
-	 */
-	 public abstract String longestCommonPrefix(String[] strs);
-	 
-	 static class Solution1 extends LongestCommonPrefix{
+    /**
+     * Write a function to find the longest common prefix string amongst an array of strings.
+     *
+     * @param strs
+     * @return
+     */
+    public abstract String longestCommonPrefix(String[] strs);
+
+    static class Solution1 extends LongestCommonPrefix {
+
+        @Override
+        public String longestCommonPrefix(String[] strs) {
+            if (strs == null || strs.length == 0)
+                return "";
+            String str = strs[0];
+            int end = 0;
+            boolean flag = false;/*whether comparison is over*/
+            if (str == null || str.length() == 0)
+                return "";
+            if (strs.length == 1)
+                return str;
+            while (end < strs[0].length()) {
+                for (int i = 1; i < strs.length; i++) {
+                    if (strs[i] == null || strs[i].length() - 1 < end) {
+                        flag = true;
+                        break;
+                    }
+                    if (strs[i].charAt(end) != str.charAt(end)) {
+                        flag = true;
+                        break;
+                    }
+                }
+                if (!flag)
+                    end++;
+                else {
+                    if (end == 0) end = -1;
+                    break;
+                }
+            }
+            return end == -1 ? "" : str.substring(0, end);
+        }
 
-		@Override
-		public String longestCommonPrefix(String[] strs) {
-			if(strs==null||strs.length==0)
-				return "";
-			String str=strs[0];
-			int end=0;
-			boolean flag=false;/*whether comparison is over*/
-			if(str==null||str.length()==0)
-				return "";
-			if(strs.length==1)
-				return str;
-			while(end<strs[0].length()){
-				for(int i=1;i<strs.length;i++){
-					if(strs[i]==null||strs[i].length()-1<end){
-						flag=true;
-						break;
-					}
-					if(strs[i].charAt(end)!=str.charAt(end)){
-						flag=true;
-						break;
-					}
-				}
-				if(!flag)
-					end++;
-				else{
-					if(end==0) end=-1;
-					break;
-				}
-			}
-			return end==-1?"":str.substring(0, end);
-		}
-		 
-	 }
+    }
 }