fd

Author: dingjikerbo

README.md

@@ -388,6 +388,7 @@
 |681|[Next Closest Time](https://leetcode.com/problems/next-closest-time/)|[Java](leetcode/solution/src/NextClosestTime.java)|80|这题多做几遍|
 |684|[Redundant Connection](https://leetcode.com/problems/redundant-connection/)| [Java](leetcode/solution/src/RedundantConnection.java)|||
 |695|[Max Area of Island](https://leetcode.com/problems/max-area-of-island/)|[Java](leetcode/solution/src/MaxAreaOfIsland.java)|100||
+|703|[Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)|[Java](leetcode/solution/src/KthLargestElementInAStream.java)|100||
 |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/)|[Java](leetcode/solution/src/JewelsAndStones.java)|100||
 |819|[Most Common Word](https://leetcode.com/problems/most-common-word/)|[Java](leetcode/solution/src/MostCommonWord.java)|85||
 |904|[Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/)|[Java](leetcode/solution/src/FruitIntoBaskets.java)|90||

leetcode/solution/src/KthLargestElementInAStream.java

@@ -0,0 +1,26 @@
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class KthLargestElementInAStream {
+
+    class KthLargest {
+
+        Queue<Integer> queue = new PriorityQueue<>();
+        int capacity;
+
+        public KthLargest(int k, int[] nums) {
+            capacity = k;
+            for (int n : nums) {
+                queue.offer(n);
+            }
+        }
+
+        public int add(int val) {
+            queue.offer(val);
+            while (queue.size() > capacity) {
+                queue.poll();
+            }
+            return queue.peek();
+        }
+    }
+}

leetcode/solution/src/KthLargestElementInArray.java

@@ -2,6 +2,9 @@
 import java.util.PriorityQueue;
 import java.util.Random;
 
+/**
+ * 注意本题不是返回第k大的distinct number
+ */
 public class KthLargestElementInArray {
 
     // 耗时15ms，时间复杂度O(nlgk)，空间复杂度O(k)

leetcode/solution/src/ThirdMaximumNumber.java

@@ -4,32 +4,24 @@
 public class ThirdMaximumNumber {
 
     public int thirdMax(int[] nums) {
-        int count = 0;
-
         long first = (long) Integer.MIN_VALUE - 1;
-        long second = (long) Integer.MIN_VALUE - 1;
-        long third = (long) Integer.MIN_VALUE - 1;
+        long second = first, third = first;
 
-        for (int n : nums) {
-            if (n == first || n == second || n == third) {
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == first || nums[i] == second || nums[i] == third) {
                 continue;
             }
-
-            if (n > first) {
-                count++;
+            if (nums[i] > first) {
                 third = second;
                 second = first;
-                first = n;
-            } else if (n > second) {
-                count++;
+                first = nums[i];
+            } else if (nums[i] > second) {
                 third = second;
-                second = n;
-            } else if (n >= third) {
-                count++;
-                third = n;
+                second = nums[i];
+            } else if (nums[i] > third) {
+                third = nums[i];
             }
         }
-
-        return (int) (count >= 3 ? third : first);
+        return (int) (third >= Integer.MIN_VALUE ? third : first);
     }
 }

leetcode/src/Main.java

@@ -4,54 +4,31 @@ public class Main {
 
     public static class Solution {
 
-        public int findKthLargest(int[] nums, int k) {
-            shuffle(nums);
-            return findKthLargest(nums, 0, nums.length - 1, k);
-        }
 
-        private void shuffle(int[] nums) {
-            Random rnd = new Random(System.currentTimeMillis());
-            for (int i = nums.length - 1; i > 1; i--) {
-                int index = rnd.nextInt(i + 1);
-                swap(nums, index, i);
-            }
-        }
 
-        public int findKthLargest(int[] nums, int start, int end, int k) {
-            int index = partition(nums, start, end);
-            int count = end - index + 1;
-            if (count < k) {
-                return findKthLargest(nums, start, index - 1, k - count);
-            } else if (count > k) {
-                return findKthLargest(nums, index + 1, end, k);
-            } else {
-                return nums[index];
-            }
-        }
+    }
+
+    class KthLargest {
+
+        Queue<Integer> queue = new PriorityQueue<>();
+        int capacity;
 
-        private int partition(int[] nums, int start, int end) {
-            int left = start, right = end -1, pivot = nums[end];
-            for (int i = start; i < right; ) {
-                if (nums[i] < pivot) {
-                    swap(nums, left++, i++);
-                } else if (nums[i] > pivot) {
-                    swap(nums, right--, i);
-                } else {
-                    i++;
-                }
+        public KthLargest(int k, int[] nums) {
+            capacity = k;
+            for (int n : nums) {
+                queue.offer(n);
             }
-            swap(nums, left, end);
-            return left;
         }
 
-        private void swap(int[] nums, int i, int j) {
-            int t = nums[i];
-            nums[i] = nums[j];
-            nums[j] = t;
+        public int add(int val) {
+            queue.offer(val);
+            while (queue.size() > capacity) {
+                queue.poll();
+            }
+            return queue.peek();
         }
     }
 
-
     public static void main(String[] args) {
         Solution solution = new Solution();
     }