update

Author: xiaoyaoworm

215_findKthLargest.java

@@ -0,0 +1,78 @@
+Quick Select解法：
+算法复杂度：average -- O(n), worst -- O(n^2)
+
+public class Solution {
+    public int findKthLargest(int[] nums, int k) { 
+        int n = nums.length;
+        int index = partition(nums,0,n-1,n+1-k);
+        return nums[index];
+    }
+    
+    public int partition(int[] nums, int l, int r, int k){
+        int pivot = nums[r];
+        int storeIndex = l;
+        for(int i = l; i < r; i++){
+            if(nums[i]<= pivot){
+                swap(nums,i, storeIndex);
+                storeIndex++;
+            }
+        }
+        swap(nums, storeIndex,r);
+        int left = storeIndex+1-l;
+        if(left == k) return storeIndex;
+        else if(left < k) return partition(nums, storeIndex+1, r, k-left);
+        else return partition(nums,l, storeIndex-1,k);
+    }
+
+    private void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+
+
+
+
+PQ解法,时间复杂度:构建整个的heap的PQ，用时是NlogN，插入操作是logN，但因为我们要插入N个点，所以O(NlogN)。
+注意pq不加comparator实现的是MIN HEAP,所以升序解里面保证最小值都被踢掉了，最后pq里面剩下了k个值，peek的那个就是第k个最大值。
+
+
+升序解：
+public class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
+        for(int num: nums){
+            pq.offer(num);
+            while(pq.size()>k){
+                pq.poll();
+            }
+        }
+        return pq.peek();
+    }
+}
+
+降序解：
+Collections.reverseOrder()是这个Comparator！！！可代替它！
+
+public class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        int result = 0;
+        Comparator<Integer> comparator = new Comparator<Integer>(){
+            public int compare(Integer a, Integer b){
+                return b-a;
+            }
+        };
+        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(nums.length, comparator);
+        for(int num: nums){
+            pq.offer(num);
+        }
+        while(k > 0){
+            result = pq.poll();
+            k--;
+        }
+        return result;
+    }
+}
+
+

36_validSudoku.java

@@ -1,3 +1,33 @@
+更简洁的写法，用一个长方形划定一个区域，检测其为valid or not：
+public class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        for(int i = 0; i < 9; i++){
+            if(!isValid(board,0,i,8,i)) return false; //check col
+            if(!isValid(board,i,0,i,8)) return false; //check row
+        }
+        
+        for(int i = 0; i < 3; i++){
+            for(int j = 0; j < 3; j++){
+                if(!isValid(board,i*3,j*3,i*3+2,j*3+2)) return false;
+            }
+        }
+        return true;
+    }
+    
+    public boolean isValid(char[][] board, int x1, int y1, int x2, int y2){
+        HashSet<Character> set = new HashSet<Character>();
+        for(int i = x1; i <= x2; i++){
+            for(int j = y1; j <= y2; j++){
+                if(board[i][j] == '.') continue;
+                if(set.contains(board[i][j])) return false;
+                else set.add(board[i][j]);
+            }
+        }
+        return true;
+    }
+}
+
+
 //http://xiaoyaoworm.com/blog/2015/04/14/%E6%96%B0leetcode-hashtable-1-valid-sudoku/
 
 public class Solution {

49_groupAnagrams.java

@@ -0,0 +1,24 @@
+public class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        List<List<String>> result = new ArrayList<List<String>>();
+        if(strs == null || strs.length == 0) return result;
+        
+        HashMap<String, List<String>> map = new HashMap<String, List<String>>();
+        
+        for(String str: strs){
+            char[] arr = str.toCharArray();
+            Arrays.sort(arr);
+            String key = new String(arr);
+            if(map.containsKey(key)) map.get(key).add(str);
+            else {
+                List<String> list = new ArrayList<String>();
+                list.add(str);
+                map.put(key,list);
+            }
+        }
+        for(String k: map.keySet()){
+            result.add(map.get(k));
+        }
+        return result;
+    }
+}

54_spiralOrder.java

@@ -0,0 +1,38 @@
+public class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> result = new ArrayList<Integer>();
+        if(matrix == null || matrix.length == 0) return result;
+        
+        int rowStart = 0;
+        int rowEnd = matrix.length-1;
+        int colStart = 0;
+        int colEnd = matrix[0].length-1;
+        
+        while(rowStart <= rowEnd && colStart <= colEnd){ //&& AND relation!!!
+            for(int i = colStart; i <= colEnd; i++){
+                result.add(matrix[rowStart][i]);
+            }
+            rowStart++;
+            
+            for(int i = rowStart; i <= rowEnd; i++){
+                result.add(matrix[i][colEnd]);
+            }
+            colEnd--;
+            
+            if(rowStart<=rowEnd){ // dont forget!!!! because rowStart++
+                for(int i = colEnd; i >= colStart; i--){
+                    result.add(matrix[rowEnd][i]);
+                }
+            }
+            rowEnd--;
+            
+            if(colStart <= colEnd){ // dont forget!!!! because colEnd--
+                for(int i = rowEnd; i >= rowStart; i--){
+                    result.add(matrix[i][colStart]);
+                }
+            }
+            colStart++;
+        }
+        return result;
+    }
+}