Merge pull request #87 from mmhossain/csharp-solutions-heaps

Added C# solutions for Chapter 8: Heaps

Author: Destiny-02

csharp/Heaps/CombineSortedLinkedLists.cs

@@ -0,0 +1,59 @@
+using ds.ListNode;
+
+/*
+	Definition of ListNode:
+	class ListNode : IComparable<ListNode>
+	{
+		public ListNode(int val, ListNode next = null)
+		{
+			Val = val;
+			Next = next;
+		}
+
+		public int Val { get; set; }
+
+		public ListNode Next { get; set; }
+
+		// Define a custom comparator for 'ListNode', enabling the min-heap 
+		// to prioritize nodes with smaller values.
+		public int CompareTo(ListNode other)
+		{
+			return this.Val - other.Val;
+		}
+	}
+*/
+
+public class Solution
+{
+	public ListNode CombineSortedLinkedLists(ListNode[] lists)
+	{
+		PriorityQueue<ListNode, ListNode> heap = new();
+
+		// Push the head of each linked list into the heap.
+		foreach (ListNode head in lists)
+			if (head != null)
+				heap.Enqueue(head, head);
+
+		// Set a dummy node to point to the head of the output linked list.
+		ListNode dummy = new ListNode(-1);
+
+		// Create a pointer to iterate through the combined linked list as
+		// we add nodes to it.
+		ListNode curr = dummy;
+
+		while (heap.Count > 0)
+		{
+			// Pop the node with the smallest value from the heap and add it 
+			// to the output linked list
+			ListNode smallestNode = heap.Dequeue();
+			curr.Next = smallestNode;
+			curr = curr.Next;
+
+			// Push the popped node's subsequent node to the heap.
+			if (smallestNode.Next != null)
+				heap.Enqueue(smallestNode.Next, smallestNode.Next);
+		}
+
+		return dummy.Next;
+	}
+}

csharp/Heaps/KMostFrequentStringsMaxHeap.cs

@@ -0,0 +1,47 @@
+class Pair : IComparable<Pair>
+{
+    public string Str { get; }
+    public int Freq { get; }
+
+    public Pair(string str, int freq)
+    {
+        Str = str;
+        Freq = freq;
+    }
+
+    public int CompareTo(Pair other)
+    {
+        // Prioritize lexicographical order for strings with equal frequencies.
+        if (this.Freq == other.Freq)
+            return string.Compare(this.Str, other.Str, StringComparison.Ordinal);
+
+        // Otherwise, prioritize strings with higher frequencies.
+        return other.Freq - this.Freq;
+    }
+}
+
+public class Solution
+{
+    public string[] KMostFrequentStringsMaxHeap(string[] strs, int k)
+    {
+        Dictionary<string, int> freqs = [];
+        foreach (string str in strs)
+            freqs[str] = freqs.GetValueOrDefault(str) + 1;
+
+        // Create the max heap by adding all Pair objects.
+        PriorityQueue<Pair, Pair> maxHeap = new();
+        foreach ((string str, int freq) in freqs)
+        {
+            Pair pair = new Pair(str, freq);
+            maxHeap.Enqueue(pair, pair);
+        }
+
+        // Pop the most frequent string off the heap 'k' times and return 
+        // these 'k' most frequent strings.
+        List<string> result = [];
+        for (int i = 0; i < k && maxHeap.Count > 0; i++)
+            result.Add(maxHeap.Dequeue().Str);
+
+        return result.ToArray();
+    }
+}

csharp/Heaps/KMostFrequentStringsMinHeap.cs

@@ -0,0 +1,56 @@
+class Pair : IComparable<Pair>
+{
+    public string Str { get; }
+    public int Freq { get; }
+
+    public Pair(string str, int freq)
+    {
+        Str = str;
+        Freq = freq;
+    }
+
+    // Since this is a min-heap comparator, we can use the same 
+    // comparator as the one used in the max-heap, but reversing the 
+    // inequality signs to invert the priority.
+    public int CompareTo(Pair other)
+    {
+        if (this.Freq == other.Freq)
+            return string.Compare(other.Str, this.Str, StringComparison.Ordinal);
+
+        return this.Freq - other.Freq;
+    }
+}
+
+public class Solution
+{
+    public string[] KMostFrequentStringsMinHeap(string[] strs, int k)
+    {
+        Dictionary<string, int> freqs = [];
+        foreach (string str in strs)
+            freqs[str] = freqs.GetValueOrDefault(str) + 1;
+
+        PriorityQueue<Pair, Pair> minHeap = new();
+
+        foreach ((string str, int freq) in freqs)
+        {
+            Pair pair = new Pair(str, freq);
+            minHeap.Enqueue(pair, pair);
+
+            // If heap size exceeds 'k', pop the lowest frequency string to 
+            // ensure the heap only contains the 'k' most frequent words so far.
+            if (minHeap.Count > k)
+                minHeap.Dequeue();
+        }
+
+        // Return the 'k' most frequent strings by popping the remaining 'k' 
+        // strings from the heap. Since we're using a min-heap, we need to 
+        // reverse the result after popping the elements to ensure the most 
+        // frequent strings are listed first.
+        List<string> result = [];
+        while (minHeap.Count > 0)
+            result.Add(minHeap.Dequeue().Str);
+
+        result.Reverse();
+        return result.ToArray();
+    }
+}

csharp/Heaps/MedianOfAnIntegerStream.cs

@@ -0,0 +1,49 @@
+public class MedianOfAnIntegerStream
+{
+    PriorityQueue<int, int> leftHalf;   // max-heap
+    PriorityQueue<int, int> rightHalf;  // min-heap
+
+    public MedianOfAnIntegerStream()
+    {
+        leftHalf = new(Comparer<int>.Create((x, y) => y - x));
+        rightHalf = new(Comparer<int>.Create((x, y) => x - y));
+    }
+
+    public void Add(int num)
+    {
+        // If 'num' is less than or equal to the max of 'leftHalf', it 
+        // belongs to the left half.
+        if (leftHalf.Count == 0 || num <= leftHalf.Peek())
+        {
+            leftHalf.Enqueue(num, num);
+
+            // Rebalance the heaps if the size of the 'leftHalf' 
+            // exceeds the size of the 'rightHalf' by more than one.
+            if (leftHalf.Count > rightHalf.Count + 1)
+            {
+                int leftTop = leftHalf.Dequeue();
+                rightHalf.Enqueue(leftTop, leftTop);
+            }
+        }
+        // Otherwise, it belongs to the right half.
+        else
+        {
+            rightHalf.Enqueue(num, num);
+
+            // Rebalance the heaps if 'rightHalf' is larger than 'leftHalf'.
+            if (leftHalf.Count < rightHalf.Count)
+            {
+                int rightTop = rightHalf.Dequeue();
+                leftHalf.Enqueue(rightTop, rightTop);
+            }
+        }
+    }
+
+    public double GetMedian()
+    {
+        if (leftHalf.Count == rightHalf.Count)
+            return (leftHalf.Peek() + rightHalf.Peek()) / 2.0;
+
+        return leftHalf.Peek();
+    }
+}

csharp/Heaps/SortAKSortedArray.cs

@@ -0,0 +1,29 @@
+public class Solution
+{
+    public int[] SortAKSortedArray(int[] nums, int k)
+    {
+        PriorityQueue<int, int> minHeap = new(Comparer<int>.Create((x, y) => x - y));
+
+        // Populate a min-heap with the first k + 1 values in 'nums'.
+        for (int i = 0; i < k + 1; i++)
+            minHeap.Enqueue(nums[i], nums[i]);
+
+        // Replace elements in the array with the minimum from the heap at each iteration.
+        int insertIndx = 0;
+        for (int i = k + 1; i < nums.Length; i++)
+        {
+            nums[insertIndx] = minHeap.Dequeue();
+            insertIndx++;
+            minHeap.Enqueue(nums[i], nums[i]);
+        }
+
+        // Pop the remaining elements from the heap to finish sorting the array.
+        while (minHeap.Count > 0)
+        {
+            nums[insertIndx] = minHeap.Dequeue();
+            insertIndx++;
+        }
+
+        return nums;
+    }
+}