diff --git a/csharp/0295-find-median-from-data-stream.cs b/csharp/0295-find-median-from-data-stream.cs
index e71840f6e..1e11a2796 100644
--- a/csharp/0295-find-median-from-data-stream.cs
+++ b/csharp/0295-find-median-from-data-stream.cs
@@ -1,23 +1,40 @@
 public class MedianFinder {
+    private PriorityQueue<int, int> leftHeap = new(Comparer<int>.Create((a, b) => b - a));
+    private PriorityQueue<int, int> rightHeap = new();
 
-    List<int> Nums;
     public MedianFinder() {
         
-        Nums = new List<int>();
     }
     
+    // T: log(n)
     public void AddNum(int num) {
-        int index = Nums.BinarySearch(num);
-        if (index < 0)
-        {
-            index = ~index;  
-        }        
-        Nums.Insert(index, num);
+        if (leftHeap.Count == 0 || num > leftHeap.Peek()) 
+            rightHeap.Enqueue(num, num);
+        else 
+            leftHeap.Enqueue(num, num);
+
+        Balance();
+    }
+
+    private void Balance() {
+        var (big, small) = leftHeap.Count > rightHeap.Count
+            ? (leftHeap, rightHeap)
+            : (rightHeap, leftHeap);
+        
+        while (big.Count - small.Count > 1) {
+            var value = big.Dequeue();
+            small.Enqueue(value, value);
+        }
     }
     
+    // T: O(1)
     public double FindMedian() {
-         int count = Nums.Count;
-        return count % 2 == 0 ? (double)((Nums[count / 2 - 1] + Nums[count / 2]) * 0.5) : Nums[count / 2];
+        if (leftHeap.Count == rightHeap.Count) 
+            return (leftHeap.Peek() + rightHeap.Peek()) / 2.0;
+
+        return leftHeap.Count > rightHeap.Count
+            ? leftHeap.Peek()
+            : rightHeap.Peek(); 
     }
 }
 
@@ -26,59 +43,4 @@ public double FindMedian() {
  * MedianFinder obj = new MedianFinder();
  * obj.AddNum(num);
  * double param_2 = obj.FindMedian();
- 
- // ***IMP : Not passing for few test cases 
-    class MedianFinder
-    {
-
-        private PriorityQueue<int, int> smallHeap; //small elements - maxHeap
-        private PriorityQueue<int, int> largeHeap; //large elements - minHeap
-
-        public MedianFinder()
-        {
-            smallHeap = new PriorityQueue<int, int>();
-            largeHeap = new PriorityQueue<int, int>();
-        }
-
-        public void addNum(int num)
-        {
-            smallHeap.Enqueue(num, num);
-            if (
-                smallHeap.Count - largeHeap.Count > 1 ||
-                !(largeHeap.Count <= 0) &&
-                smallHeap.Peek() > largeHeap.Peek()
-            )
-            {
-                if (smallHeap.Count > 0)
-                {
-                    int ele = smallHeap.Dequeue();
-                    largeHeap.Enqueue(ele, ele);
-                }
-            }
-            if (largeHeap.Count - smallHeap.Count > 1)
-            {
-                if (largeHeap.Count > 0)
-                {
-                    int ele = largeHeap.Dequeue();
-                    smallHeap.Enqueue(ele, ele);
-                }
-            }
-        }
-
-        public double findMedian()
-        {
-            if (smallHeap.Count == largeHeap.Count)
-            {
-                return (double)(largeHeap.Peek() + smallHeap.Peek()) / 2;
-            }
-            else if (smallHeap.Count > largeHeap.Count)
-            {
-                return (double)smallHeap.Peek();
-            }
-            else
-            {
-                return (double)largeHeap.Peek();
-            }
-        }
-    }
  */