Print all elements in sorted order from row and column wise sorted matrix

// A C# program to Print all elements 
// in sorted order from row and 
// column wise sorted matrix 
using System;

class GFG
{
    static int INF = int.MaxValue;
    static int N = 4;

    // A utility function to youngify a Young Tableau. 
    // This is different from standard youngify. 
    // It assumes that the value at mat[0][0] is infinite. 
    static void youngify(int [,]mat, int i, int j)
    {
        // Find the values at down and right sides of mat[i][j] 
        int downVal = (i + 1 < N) ? 
                    mat[i + 1,j] : INF;
        int rightVal = (j + 1 < N) ? 
                    mat[i,j + 1] : INF;

        // If mat[i][j] is the down right corner element, 
        // return 
        if (downVal == INF && rightVal == INF) 
        {
            return;
        }

        // Move the smaller of two values 
        // (downVal and rightVal) to mat[i][j] 
        // and recur for smaller value 
        if (downVal < rightVal)
        {
            mat[i,j] = downVal;
            mat[i + 1,j] = INF;
            youngify(mat, i + 1, j);
        } 
        else
        {
            mat[i, j] = rightVal;
            mat[i, j + 1] = INF;
            youngify(mat, i, j + 1);
        }
    }

    // A utility function to extract 
    // minimum element from Young tableau 
    static int extractMin(int [,]mat) 
    {
        int ret = mat[0,0];
        mat[0, 0] = INF;
        youngify(mat, 0, 0);
        return ret;
    }

    // This function uses extractMin() 
    // to print elements in sorted order 
    static void printSorted(int [,]mat) 
    {
            Console.WriteLine("Elements of matrix in sorted order n");
        for (int i = 0; i < N * N; i++) 
        {
            Console.Write(extractMin(mat) + " ");
        }
    }

    // Driver Code
    static public void Main ()
    {
        int [,]mat = {{10, 20, 30, 40},
                    {15, 25, 35, 45},
                    {27, 29, 37, 48},
                    {32, 33, 39, 50}};
        printSorted(mat);
    }
}

// This code is contributed by ajit.

using System;
using System.Collections.Generic;

public static class GFG {

    // Function to print all elements of matrix in sorted
    // orderd
    static void sortedMatrix(int N, List<List<int> > Mat)
    {
        List<int> temp = new List<int>();

        // Store all elements of matrix into temp
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                temp.Add(Mat[i][j]);
            }
        }

        // Sort the temp
        temp.Sort();

        // Print the values of temp
        for (int i = 0; i < temp.Count; i++) {
            Console.Write(temp[i]);
            Console.Write(" ");
        }
    }

    public static void Main()
    {
        int N = 4;
        List<List<int> > Mat = new List<List<int> >() {
            new List<int>{ 10, 20, 30, 40 },
                new List<int>{ 15, 25, 35, 45 },
                new List<int>{ 27, 29, 37, 48 },
                new List<int>
            {
                32, 33, 39, 50
            }
        };
        sortedMatrix(N, new List<List<int> >(Mat));
    }

    // This code is contributed by Aarti_Rathi
}

using System;
using System.Collections.Generic;

// Define a class to represent a node in the min heap
class MinHeapNode {
    public int element; // The value of the element in the node
    public int i; // The row index of the element in the matrix
    public int j; // The column index of the element in the matrix

    // Constructor to create a new node with the given values
    public MinHeapNode(int element, int i, int j) {
        this.element = element;
        this.i = i;
        this.j = j;
    }
}

// Define a class to represent a min heap data structure
class MinHeap {
    public int heapSize; // The number of elements in the heap
    public MinHeapNode[] harr; // An array to store the heap elements

    // Constructor to create a new heap from the given array of nodes
    public MinHeap(MinHeapNode[] a, int size) {
        harr = a;
        heapSize = size;

        // Starting from the last non-leaf node and moving up, 
        // apply the minHeapify operation to all nodes in the heap
        int i = (heapSize - 1) / 2;
        while (i >= 0) {
            minHeapify(i);
            i--;
        }
    }

    // Method to maintain the min heap property of the tree rooted at index i
    public void minHeapify(int i) {
        int l = left(i);
        int r = right(i);
        int smallest = i;

        // If the left child is smaller than the parent, mark it as the smallest
        if (l < heapSize && harr[l].element < harr[i].element) {
            smallest = l;
        }

        // If the right child is smaller than the smallest so far, mark it as the smallest
        if (r < heapSize && harr[r].element < harr[smallest].element) {
            smallest = r;
        }

        // If the smallest element is not the parent, swap it with the parent 
        // and recursively apply minHeapify to the subtree rooted at the smallest element
        if (smallest != i) {
            MinHeapNode temp = harr[i];
            harr[i] = harr[smallest];
            harr[smallest] = temp;
            minHeapify(smallest);
        }
    }

    // Method to compute the index of the left child of a node at index i
    public int left(int i) { return 2 * i + 1; }

    // Method to compute the index of the right child of a node at index i
    public int right(int i) { return 2 * i + 2; }

    // Method to get the minimum element from the heap (i.e., the root of the tree)
    public MinHeapNode getMin() { return harr[0]; }

    // Method to replace the minimum element in the heap with a new element x,
    // and then restore the min heap property of the tree
    public void replaceMin(MinHeapNode x) {
        harr[0] = x;
        minHeapify(0);
    }
}
class Program {
    static int N = 4;

    static void printSorted(int[][] mat) {
        // Create a new MinHeapNode array and fill it with the first element from each row in the matrix.
        MinHeapNode[] harr = new MinHeapNode[N];
        for (int i = 0; i < N; i++) {
            harr[i] = new MinHeapNode(mat[i][0], i, 1);
        }

        // Create a new MinHeap and pass the array and its size to its constructor. 
        MinHeap heap = new MinHeap(harr, N);

        // Traverse the entire matrix by looping N*N times
        for (int count = 0; count < N * N; count++) {
            // Get the minimum element from the heap and print it
            MinHeapNode root = heap.getMin();
            Console.Write(root.element + " ");

            // If there are more elements in the row that contains the minimum element, 
            // replace the minimum element in the heap with the next element in the row
            if (root.j < N) {
                root.element = mat[root.i][root.j];
                root.j += 1;
            } else {
                // If we have reached the end of the row, replace the minimum element in the heap with infinity
                root.element = int.MaxValue;
            }

            // Replace the root with the new element in the heap
            heap.replaceMin(root);
        }
    }

    static void Main(string[] args) {
        // Initialize a 2D matrix
        int[][] mat = {
                new int[]{10, 20, 30, 40},
                new int[]{15, 25, 35, 45},
                new int[]{27, 29, 37, 48},
                new int[]{32, 33, 39, 50}
        };

        // Call the printSorted function with the matrix as argument
        printSorted(mat);
    }
}