update 703

Author: fishercoder1534

paginated_contents/algorithms/1st_thousand/README.md

@@ -170,7 +170,7 @@
 | 706 | [Design HashMap](https://leetcode.com/problems/design-hashmap/)                                                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_706.java)                                                                  |                                                                               | Easy                             | Design                                                               
 | 705 | [Design HashSet](https://leetcode.com/problems/design-hashset/)                                                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_705.java)                                                                  |                                                                               | Easy                             | Design                                                               
 | 704 | [Binary Search](https://leetcode.com/problems/binary-search/)                                                                                                                                 | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_704.java)                                                                  | [:tv:](https://youtu.be/eHVe_uyXeWg)                                          | Easy                             | Binary Search                                                        
-| 703 | [Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)                                                                                             | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_703.java)                                                                  |                                                                               | Easy                             |
+| 703 | [Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)                                                                                             | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_703.java)                                                                  |                                                                               | Easy                             | PriorityQueue, Design
 | 701 | [Insert into a Binary Search Tree](https://leetcode.com/problems/insert-into-a-binary-search-tree/)                                                                                           | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_701.java)                                                                  |                                                                               | Medium                           | DFS, recursion                                                       
 | 700 | [Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/)                                                                                               | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_700.java)                                                                  |                                                                               | Easy                             | recusion, dfs                                                        
 | 699 | [Falling Squares](https://leetcode.com/problems/falling-squares/)                                                                                                                             | [Solution](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/firstthousand/_699.java)                                                                  || Hard                                                                          | Segment Tree                     

src/main/java/com/fishercoder/solutions/firstthousand/_703.java

@@ -1,37 +1,32 @@
 package com.fishercoder.solutions.firstthousand;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.PriorityQueue;
 
 public class _703 {
     public static class Solution1 {
         public static class KthLargest {
-            PriorityQueue<Integer> heap;
+            PriorityQueue<Integer> minHeap;
             int maxK;
 
             public KthLargest(int k, int[] nums) {
-                heap = new PriorityQueue<>(Collections.reverseOrder());
+                minHeap = new PriorityQueue<>();
                 for (int num : nums) {
-                    heap.offer(num);
+                    minHeap.offer(num);
+                    if (minHeap.size() > k) {
+                        minHeap.poll();
+                    }
                 }
                 maxK = k;
             }
 
             public int add(int val) {
-                List<Integer> tmp = new ArrayList<>();
-                int result = 0;
-                int tmpK = maxK;
-                heap.offer(val);
-                while (tmpK-- > 0) {
-                    result = heap.poll();
-                    tmp.add(result);
+                if (minHeap.size() < maxK || minHeap.peek() < val) {
+                    minHeap.offer(val);
+                    if (minHeap.size() > maxK) {
+                        minHeap.poll();
+                    }
                 }
-                for (int num : tmp) {
-                    heap.offer(num);
-                }
-                return result;
+                return minHeap.peek();
             }
         }
     }

src/test/java/com/fishercoder/firstthousand/_703Test.java

@@ -6,16 +6,16 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class _703Test {
-  private _703.Solution1.KthLargest solution1;
-  private static int[] A;
+    private _703.Solution1.KthLargest solution1;
+    private static int[] A;
 
-  @Test
-  public void test1() {
-    solution1 = new _703.Solution1.KthLargest(3, new int[] {4, 5, 8, 2});
-    assertEquals(4, solution1.add(3));
-    assertEquals(5, solution1.add(5));
-    assertEquals(5, solution1.add(10));
-    assertEquals(8, solution1.add(9));
-    assertEquals(8, solution1.add(4));
-  }
+    @Test
+    public void test1() {
+        solution1 = new _703.Solution1.KthLargest(3, new int[]{4, 5, 8, 2});
+        assertEquals(4, solution1.add(3));
+        assertEquals(5, solution1.add(5));
+        assertEquals(5, solution1.add(10));
+        assertEquals(8, solution1.add(9));
+        assertEquals(8, solution1.add(4));
+    }
 }