heap

Author: awangdev

Java/HashHeap.java

@@ -1,6 +1,6 @@
 H
 1532965421
-tags: HashHeap
+tags: HashHeap, Heap
 
 非题.是从九章找来的HashHeap implementation.
 

Java/Heapify.java

@@ -1,5 +1,5 @@
 R
-tags: Heap
+tags: Heap, MinHeap
 
 Turn unsorted array into a min-heap array, where for each A[i], 
 

Java/Kth Largest Element in an Array.java

@@ -1,6 +1,29 @@
 M
-1531896299
-tags: Divide and Conquer, Heap
+1533137926
+tags: Divide and Conquer, Heap, PriorityQueue, MinHeap, Quick Sort
+
+kth largest in array
+
+#### PriorityQueue, MinHeap
+- Need to maintain k large elements, where the smallest will be compared and dropped if applicable: 
+- Maintain k elements with min value: consider using minHeap
+- add k base elements first
+- Maintain MinHeap: only allow larger elements (which will squzze out the min value)
+- Remove peek() of queue if over size
+- O(nlogk)
+
+
+#### Quick Sort
+- 用Quick Sort 里面partion的一部分
+- sort结束后是ascending的, 那么 n - k 就是第k大. 
+- partion的结果是那个low, 去找 low==nums.size() - k， 也就是倒数第K个。    
+- 没找到继续partion recursively.
+- sort的过程是排一个从小到大的list. (同样的代码还可以好xth smallest，mid变成x就好)
+- Steps:
+- 每个iteration, 找一个pivot,然后从low,和high都和pivot作比较。    
+- 找到一个low>pivot, high<pivot, 也就可以swap了。    
+- 得到的low就是当下的partion point了
+- Overall O(nlogN), average O(n) for this problem.
 
 ```
 /**
@@ -38,4 +61,120 @@ public int findKthLargest(int[] nums, int k) {
         return queue.poll();
     }
 }
+
+
+// Quick sort/ partition
+// Partition to return the `low` index, which should match targetIndex.
+class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        if (nums == null || nums.length == 0) return -1;
+        int n = nums.length;
+        return partition(nums, 0, n - 1, n - k);
+    }
+    
+    private int partition (int[] nums, int start, int end, int targetIndex) {
+        // define low/high
+        int pivot = end;
+        int low = start, high = end, num = nums[pivot];
+        
+        // move pointer and swap
+        while (low < high) {
+            while (low < high && nums[low] < num) {
+                low++;
+            }
+            while (low < high && nums[high] >= num) {
+                high--;
+            }
+            swap(nums, low, high);
+        }
+        swap(nums, low, pivot);
+
+        // compare if low == targetIndex; or recursively partition to find targetIndex
+        if (low == targetIndex) {
+            return nums[low];
+        } else if (low < targetIndex) {
+            return partition(nums, low + 1, end, targetIndex);
+        } else {
+            return partition(nums, start, low - 1, targetIndex);
+        }
+    }
+    
+    private void swap(int[] nums, int x, int y) {
+        int temp = nums[x];
+        nums[x] = nums[y];
+        nums[y] = temp;
+    }
+}
+
+/*
+LintCode
+Find K-th largest element in an array.
+
+Example
+In array [9,3,2,4,8], the 3rd largest element is 4
+
+In array [1,2,3,4,5], the 1st largest element is 5, 
+2nd largest element is 4, 3rd largest element is 3 and etc.
+
+Note
+You can swap elements in the array
+
+Challenge
+O(n) time, O(1) space
+
+Tags Expand 
+Quick Sort Sort
+
+*/
+
+/*
+
+Thoughts:
+Almost the same as the Median problem: 
+the only difference is, this one is not looking for the middle point, but for the last kth element. 
+Using the same quick sort code with minor modifications, and we can solve this problem.
+*/
+
+class Solution {
+    //param k : description of k
+    //param numbers : array of numbers
+    //return: description of return
+    public int kthLargestElement(int k, ArrayList<Integer> nums) {
+        if (nums == null || nums.size() == 0) {
+            return 0;
+        }
+        return helper(nums, 0, nums.size() - 1, nums.size() - k);
+    }
+    
+    public void swap( ArrayList<Integer>nums, int x, int y){
+        int temp = nums.get(x);
+        nums.set(x, nums.get(y));
+        nums.set(y, temp);
+    }
+    
+    public int helper( ArrayList<Integer> nums, int start, int end, int mid) {
+        int pivot = end;
+        int num = nums.get(pivot);
+        int low = start;
+        int high = end;
+        while (low < high) {
+            while(low < high && nums.get(low) < num) {
+                low++;
+            }
+            while(low < high && nums.get(high) >= num) {
+                high--;
+            }
+            swap(nums, low, high);
+        }
+        swap(nums, low, pivot);
+        if (low == mid) {
+            return nums.get(low);
+        } else if (low < mid) {
+            return helper(nums, low + 1, end, mid);
+        } else {
+            return helper(nums, start, low - 1, mid);
+        }
+    }
+};
+
 ```

Java/Kth Largest Element.java

@@ -1,6 +1,6 @@
 M
 1521167295
-tags: Heap, Greedy, Sort, Sweep Line
+tags: Heap, Greedy, Sort, Sweep Line, PriorityQueue
 
 给一串数字pair, 代表会议的开始/结束时间. 找同时又多少个会议发生(需要多少件房间)
 
@@ -43,25 +43,18 @@
 */
 class Solution {
     class Point {
-        int pos;
-        int flag;
+        int pos, flag;
         public Point(int pos, int flag) {
             this.pos = pos;
             this.flag = flag;
         }
     }
     public int minMeetingRooms(Interval[] intervals) {
-        if (intervals == null || intervals.length == 0) {
-            return 0;
-        }
-        int count = 0;
-        int max = 0;
-        PriorityQueue<Point> queue = new PriorityQueue<Point>(new Comparator<Point>() {
-            public int compare(Point a, Point b) {
-                return a.pos - b.pos;
-            }
-        });
-        
+        if (intervals == null || intervals.length == 0) return 0;
+
+        int count = 0, max = 0;
+        // init
+        PriorityQueue<Point> queue = new PriorityQueue<>(Comparator.comparing(a -> a.pos));
         for (Interval interval: intervals) {
             queue.offer(new Point(interval.start, 1));
             queue.offer(new Point(interval.end, -1));
@@ -77,7 +70,6 @@ public int compare(Point a, Point b) {
 
             max = Math.max(count, max);
         }
-        
         return max;
     }
 }

Java/Meeting Rooms II.java

@@ -1,17 +1,19 @@
 M
-1528048508
-tags: Heap, PriorityQueue
+1533139060
+tags: Heap, PriorityQueue, MinHeap
+
+Same as merge k sorted list, use priorityQueue
 
 #### Priority Queue
 - 由Merge k sorted list启发。用PriorityQueue,存那k个首发element
 - PriorityQueue需要存储单位: 自己建一个Class Node 存val, x, y index.    
 - 因为array里没有 'next' pointer，只能存x,y来推next element
+- Not sure why `new PriorityQueue<>(Comparator.comparing(a -> a.val));` is slower
 
 ```
 /*
 Given k sorted integer arrays, merge them into one sorted array.
 
-Have you met this question in a real interview? Yes
 Example
 Given 3 sorted arrays:
 
@@ -42,19 +44,20 @@ public Node(int val, int x, int y) {
     }
 
     public int[] mergekSortedArrays(int[][] arrays) {
-        List<Integer> rst = new ArrayList<Integer>();
-        if (arrays == null || arrays.length == 0) {
-            return new int[0];
-        }
+        List<Integer> rst = new ArrayList<>();
+        if (arrays == null || arrays.length == 0) return new int[0];
 
+        
+        // Faster
+        // Somehow, slower: PriorityQueue<Node> queue = new PriorityQueue<>(Comparator.comparing(a -> a.val));
         PriorityQueue<Node> queue = new PriorityQueue<>(arrays.length,
             new Comparator<Node>() {
                 public int compare(Node a, Node b){
                     return a.val - b.val;
                 }
             }
         );
-        
+
         //init
         for (int i = 0; i < arrays.length; i++) {
             if (arrays[i].length != 0) {