Cartesian Tree Sorting

using System;
using System.Collections.Generic;

/* A binary tree node has data, pointer to left child
   and a pointer to right child */
public class Node
{
    public int data;
    public Node left, right;
}

// Creating a shortcut for int, Node* pair type
public class iNPair : IComparable<iNPair>
{
    public int first;
    public Node second;

    public iNPair(int f, Node s)
    {
        first = f;
        second = s;
    }

    public int CompareTo(iNPair other)
    {
        return first.CompareTo(other.first);
    }
}

class CartesianTreeSort
{
    // This function sorts by pushing and popping the
    // Cartesian Tree nodes in a pre-order like fashion
    static void pQBasedTraversal(Node root)
    {
        // We will use a priority queue to sort the
        // partially-sorted data efficiently.
        // Unlike Heap, Cartesian tree makes use of
        // the fact that the data is partially sorted
        PriorityQueue<iNPair> pQueue = new PriorityQueue<iNPair>();

        pQueue.Enqueue(new iNPair(root.data, root));

        // Resembles a pre-order traverse as first data
        // is printed then the left and then right child.
        while (!pQueue.IsEmpty())
        {
            iNPair poppedPair = pQueue.Dequeue();
            Console.Write(poppedPair.first + " ");

            if (poppedPair.second.left != null)
                pQueue.Enqueue(new iNPair(poppedPair.second.left.data, poppedPair.second.left));

            if (poppedPair.second.right != null)
                pQueue.Enqueue(new iNPair(poppedPair.second.right.data, poppedPair.second.right));
        }

        Console.WriteLine();
    }

    static Node buildCartesianTreeUtil(int root, int[] arr, 
                                       int[] parent, int[] leftChild, int[] rightChild)
    {
        if (root == -1)
            return null;

        Node temp = new Node();

        temp.data = arr[root];
        temp.left = buildCartesianTreeUtil(leftChild[root], arr, parent, leftChild, rightChild);
        temp.right = buildCartesianTreeUtil(rightChild[root], arr, parent, leftChild, rightChild);

        return temp;
    }

    // A function to create the Cartesian Tree in O(N) time
    static Node buildCartesianTree(int[] arr, int n)
    {
        // Arrays to hold the index of parent, left-child,
        // right-child of each number in the input array
        int[] parent = new int[n];
        int[] leftChild = new int[n];
        int[] rightChild = new int[n];

        // Initialize all array values as -1
        Array.Fill(parent, -1);
        Array.Fill(leftChild, -1);
        Array.Fill(rightChild, -1);

        // 'root' and 'last' stores the index of the root and the
        // last processed of the Cartesian Tree.
        // Initially, we take the root of the Cartesian Tree as the
        // first element of the input array. This can change
        // according to the algorithm
        int root = 0, last;

        // Starting from the second element of the input array
        // to the last on scan across the elements, adding them
        // one at a time.
        for (int i = 1; i <= n - 1; i++)
        {
            last = i - 1;
            rightChild[i] = -1;

            // Scan upward from the node's parent up to
            // the root of the tree until a node is found
            // whose value is smaller than the current one
            // This is the same as Step 2 mentioned in the
            // algorithm
            while (arr[last] >= arr[i] && last != root)
                last = parent[last];

            // arr[i] is the smallest element yet; make it
            // the new root
            if (arr[last] >= arr[i])
            {
                parent[root] = i;
                leftChild[i] = root;
                root = i;
            }

            else if (rightChild[last] == -1)
            {
                rightChild[last] = i;
                parent[i] = last;
                leftChild[i] = -1;
            }

            else
            {
                parent[rightChild[last]] = i;
                leftChild[i] = rightChild[last];
                rightChild[last] = i;
                parent[i] = last;
            }
        }

        // Since the root of the Cartesian Tree has no
        // parent, so we assign it -1
        parent[root] = -1;

        return buildCartesianTreeUtil(root, arr, parent, leftChild, rightChild);
    }

    // Sorts an input array
    static void printSortedArr(int[] arr, int n)
    {
        // Build a Cartesian tree
        Node root = buildCartesianTree(arr, n);

        Console.WriteLine("The sorted array is-");

        // Do pre-order traversal and insert
        // in priority queue
        pQBasedTraversal(root);
    }

    /* Driver program to test above functions */
    static void Main()
    {
        /*  Given input array- {5,10,40,30,28},
            its corresponding unique Cartesian Tree
            is-

            5
              \
              10
                \
                 28
                /
              30
             /
            40
        */

        int[] arr = { 5, 10, 40, 30, 28 };
        int n = arr.Length;

        printSortedArr(arr, n);
    }
}

// Priority Queue implementation for C#
public class PriorityQueue<T> where T : IComparable<T>
{
    private List<T> data;

    public PriorityQueue()
    {
        this.data = new List<T>();
    }

    public bool IsEmpty()
    {
        return this.data.Count == 0;
    }

    public void Enqueue(T item)
    {
        this.data.Add(item);
        int ci = this.data.Count - 1; // child index; start at end
        while (ci > 0)
        {
            int pi = (ci - 1) / 2; // parent index
            if (this.data[ci].CompareTo(this.data[pi]) >= 0)
                break; // child item is larger than (or equal) parent so we're done
            T tmp = this.data[ci];
            this.data[ci] = this.data[pi];
            this.data[pi] = tmp;
            ci = pi;
        }
    }

    public T Dequeue()
    {
        // assumes pq is not empty; up to calling code
        int li = this.data.Count - 1; // last index (before removal)
        T frontItem = this.data[0];   // fetch the front
        this.data[0] = this.data[li];
        this.data.RemoveAt(li);

        --li; // last index (after removal)
        int pi = 0; // parent index. start at front of pq
        while (true)
        {
            int ci = pi * 2 + 1; // left child index of parent
            if (ci > li)
                break;  // no children so done
            int rc = ci + 1;     // right child
            if (rc <= li && this.data[rc].CompareTo(this.data[ci]) < 0)
                ci = rc; // if there is a rc (ci + 1), and it is smaller than left child,
                         // use the rc instead
            if (this.data[pi].CompareTo(this.data[ci]) <= 0)
                break; // parent is smaller than (or equal to) smallest child so done
            T tmp = this.data[pi];
            this.data[pi] = this.data[ci];
            this.data[ci] = tmp; // swap parent and child
            pi = ci;
        }
        return frontItem;
    }
}