@@ -103,7 +103,7 @@ class Test(unittest.TestCase):
 
 def test_zero_matrix(self):
 for [test_matrix, expected] in self.data:
-actual = zero_matrix(test_matrix)
+actual = zero_matrix1(test_matrix)
 self.assertEqual(actual, expected)
 
 if __name__ == "__main__":

@@ -0,0 +1,15 @@
+from heapq import heappush, heappop
+
+class Solution:
+def findKthLargest(self, nums, k):
+min_heap = []
+
+for i in range(k):
+heappush(min_heap, nums[i])
+
+for i in range(k, len(nums)):
+if nums[i] > min_heap[0]:
+heappop(min_heap)
+heappush(min_heap, nums[i])
+
+return min_heap[0]

@@ -0,0 +1,17 @@
+from heapq import heappush, heapreplace
+
+class Solution:
+def kClosest(self, points, K):
+max_heap = []
+for i in range(K):
+heappush(max_heap, (-self.distance(points[i]), points[i]))
+
+for i in range(K, len(points)):
+distance, _ = max_heap[0]
+if -distance > self.distance(points[i]):
+heapreplace(max_heap, (-self.distance(points[i]), points[i]))
+
+return [items[1] for items in max_heap]
+
+def distance(self, point):
+return (point[0] ** 2) + (point[1] ** 2)

@@ -0,0 +1,17 @@
+from collections import Counter
+from heapq import heappush, heappop
+
+class Solution:
+def topKFrequent(self, nums, k):
+res = []
+max_heap = []
+nums_freq = Counter(nums)
+
+for num, freq in nums_freq.items():
+heappush(max_heap, (-freq, num))
+
+for _ in range(k):
+freq, num = heappop(max_heap)
+res.append(num)
+
+return res

@@ -0,0 +1,19 @@
+from collections import Counter
+from heapq import heappush, heappop
+
+class Solution:
+def frequencySort(self, s: str) -> str:
+char_freq = Counter(s)
+max_heap = []
+res = []
+
+for char, freq in char_freq.items():
+heappush(max_heap, (-freq, char))
+
+while max_heap:
+item = heappop(max_heap)
+freq = -item[0]
+char = item[1]
+res.append(char * freq)
+
+return ''.join(res)

@@ -0,0 +1,17 @@
+import heapq
+
+class KthLargest:
+
+def __init__(self, k, nums):
+self.heap = []
+self.k = k
+
+for num in nums:
+self.add(num)
+
+def add(self, val: int) -> int:
+heapq.heappush(self.heap, val)
+if len(self.heap) > self.k:
+heapq.heappop(self.heap)
+
+return self.heap[0]

@@ -0,0 +1,35 @@
+from heapq import heappush, heappop
+
+class Solution:
+def findClosestElements(self, arr, k, x):
+x_idx = self.binarySearch(arr, x)
+low = max(x_idx - k, 0)
+high = min(x_idx + k, len(arr) - 1)
+minheap = []
+
+for i in range(low, high+1):
+heappush(minheap, (abs(arr[i] - x), arr[i]))
+
+result = []
+for _ in range(k):
+result.append(heappop(minheap)[1])
+
+result.sort()
+return result
+
+
+def binarySearch(self, arr, x):
+l = 0
+r = len(arr) - 1
+
+while l < r:
+mid = l + (r - l) // 2
+
+if arr[mid] == x:
+return mid
+elif arr[mid] > x:
+r = mid - 1
+else:
+l = mid + 1
+
+return l