Kth smallest element in a row-wise and column-wise sorted 2D array

//C# program to find the Kth smallest element
using System;
using System.Collections.Generic;

class Program
{
    // Function to find the kth smallest element in a sorted 2D matrix
    static int FindKthSmallest(int[,] matrix, int k)
    {
        int n = matrix.GetLength(0);

        // Create a list to store all elements
        List<int> elements = new List<int>();

        // Store all elements of the matrix into the list
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                elements.Add(matrix[i, j]);
            }
        }

        // Sort the list
        elements.Sort();

        // Return the kth smallest element (1-based index, hence k-1)
        return elements[k - 1];
    }

    static void Main()
    {
        // Define the sorted 2D matrix
        int[,] matrix = {
            { 1, 5, 9 },
            { 10, 11, 13 },
            { 12, 13, 15 }
        };

        // Find the 8th smallest element
        int k = 8;
        int result = FindKthSmallest(matrix, k);

        // Use traditional string concatenation instead of string interpolation
        Console.WriteLine("The " + k + "th smallest element is: " + result);
    }
}

//C# program to find the Kth smallest element using priority queue
using System;
using System.Collections.Generic;

class MaxHeap<T> where T : IComparable<T>
{
    private readonly List<T> _heap;
    private readonly int _capacity;

    public MaxHeap(int capacity)
    {
        _heap = new List<T>(capacity);
        _capacity = capacity;
    }

    public int Count => _heap.Count;

    public void Add(T item)
    {
        if (_heap.Count < _capacity)
        {
            _heap.Add(item);
            HeapifyUp(_heap.Count - 1);
        }
        else if (_heap.Count > 0 && item.CompareTo(_heap[0]) < 0)
        {
            _heap[0] = item;
            HeapifyDown(0);
        }
    }

    public T Peek()
    {
        if (_heap.Count == 0)
            throw new InvalidOperationException("Heap is empty.");
        return _heap[0];
    }

    private void HeapifyUp(int index)
    {
        int parentIndex = (index - 1) / 2;
        if (index > 0 && _heap[index].CompareTo(_heap[parentIndex]) > 0)
        {
            Swap(index, parentIndex);
            HeapifyUp(parentIndex);
        }
    }

    private void HeapifyDown(int index)
    {
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        int largest = index;

        if (leftChild < _heap.Count && _heap[leftChild].CompareTo(_heap[largest]) > 0)
        {
            largest = leftChild;
        }

        if (rightChild < _heap.Count && _heap[rightChild].CompareTo(_heap[largest]) > 0)
        {
            largest = rightChild;
        }

        if (largest != index)
        {
            Swap(index, largest);
            HeapifyDown(largest);
        }
    }

    private void Swap(int i, int j)
    {
        T temp = _heap[i];
        _heap[i] = _heap[j];
        _heap[j] = temp;
    }
}

class Program
{
    // Function to find the kth smallest element in a sorted 2D matrix using a max-heap
    static int FindKthSmallest(int[,] matrix, int k)
    {
        int n = matrix.GetLength(0);
        // Max-heap to store k smallest elements
        var maxHeap = new MaxHeap<int>(k);

        // Traverse all elements in the matrix
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                int currentElement = matrix[i, j];
                maxHeap.Add(currentElement);
            }
        }

        // The top element of the max-heap is the kth smallest element
        return maxHeap.Peek();
    }

    static void Main()
    {
        // Define the sorted 2D matrix
        int[,] matrix = {
            { 1, 5, 9 },
            { 10, 11, 13 },
            { 12, 13, 15 }
        };

        // Find the 8th smallest element
        int k = 8;
        int result = FindKthSmallest(matrix, k);

        Console.WriteLine($"The {k}th smallest element is: {result}");
    }
}

//C# program to find the Kth smallest element using Binary Serach

using System;

class GFG {
    // Function to count the number of elements less than or equal to x
    static int CountSmallerEqual(int[,] matrix, int x) {
        int n = matrix.GetLength(0);
        int count = 0;
        int row = 0;
        int col = n - 1;

        // Traverse from the top-right corner
        while (row < n && col >= 0) {
            if (matrix[row, col] <= x) {
                // If current element is less than or equal to x,
                // all elements in this row up to the current column are <= x
                count += (col + 1);
                row++;
            } else {
                // Move left in the matrix
                col--;
            }
        }

        return count;
    }

    // Function to find the Kth smallest element in a sorted 2D matrix using binary search
    static int FindKthSmallest(int[,] matrix, int k) {
        int n = matrix.GetLength(0);
        int low = matrix[0, 0];
        int high = matrix[n - 1, n - 1];
        int ans = 0;

        while (low <= high) {
            int mid = low + (high - low) / 2;
            
            // Count elements less than or equal to mid
            int count = CountSmallerEqual(matrix, mid);

            if (count < k) {
                // If there are less than k elements <= mid, the kth smallest is larger
                low = mid + 1;
            } else {
                // Otherwise, mid might be the answer, but we need to check for smaller values
                ans = mid;
                high = mid - 1;
            }
        }

        return ans;
    }

    static void Main() {
        // Define the sorted 2D matrix
        int[,] matrix = {
            {1, 5, 9},
            {10, 11, 13},
            {12, 13, 15}
        };
        
        // Find the Kth smallest element
        int k = 8;
        int result = FindKthSmallest(matrix, k);
        
        Console.WriteLine("The " + k + "th smallest element is: " + result);
    }
}