find N largest elements from a Linked list

using System;

class Node
{
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

class LinkedList
{
    private Node head;

    public LinkedList()
    {
        head = null;
    }

    // Function to insert a Node at the beginning of the linked list
    public void InsertAtBegin(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Function to print the N largest elements in the linked list
    public void PrintNLargest(int N)
    {
        BubbleSort();
        Node current = head;

        for (int i = 0; i < N && current != null; i++)
        {
            Console.Write(current.data + " ");
            current = current.next;
        }
        Console.WriteLine();
    }

    // Function to sort the linked list using Bubble Sort
    private void BubbleSort()
    {
        if (head == null || head.next == null)
            return;

        bool swapped;
        do
        {
            Node prev = null;
            Node current = head;
            swapped = false;

            while (current.next != null)
            {
                if (current.data < current.next.data)
                {
                    Node temp = current.next;
                    current.next = temp.next;
                    temp.next = current;

                    if (prev == null)
                        head = temp;
                    else
                        prev.next = temp;

                    prev = temp;
                    swapped = true;
                }
                else
                {
                    prev = current;
                    current = current.next;
                }
            }
        } while (swapped);
    }
}

class Program
{
    static void Main(string[] args)
    {
        LinkedList linkedList = new LinkedList();
        int[] arr = { 4, 5, 1, 2, 9 };
        int N = 2;

        foreach (int num in arr)
        {
            linkedList.InsertAtBegin(num);
        }
      
        linkedList.PrintNLargest(N);
    }
}

using System;
using System.Collections.Generic;

// Define a linked list node structure
public class Node
{
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

public class Program
{
    // Function to find N largest elements
    public static List<int> FindNLargestElements(Node head, int N)
    {
        // Create a max-heap by implementing a min-heap with reversed ordering
        var pq = new PriorityQueue<int>((x, y) => y.CompareTo(x));

        // Traverse the linked list and insert elements into the maxHeap
        while (head != null)
        {
            pq.Enqueue(head.data);
            head = head.next;
        }

        // Pop N largest elements from the maxHeap
        var result = new List<int>();
        for (int i = 0; i < N; i++)
        {
            if (pq.Count > 0)
            {
                result.Add(pq.Dequeue());
            }
        }

        return result;
    }

    // Function to print a list
    public static void Print(List<int> list)
    {
        foreach (var num in list)
        {
            Console.Write(num + " ");
        }
        Console.WriteLine();
    }

    // Define a function to insert a node at the beginning of the linked list
    public static void InsertAtTheBegin(ref Node head, int data)
    {
        var newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    public static void Main()
    {
        int[] arr = { 81, 52, 45, 10, 3, 2, 96 };
        int N = 3;

        Node start = null;

        // Create a linked list from the array
        for (int i = arr.Length - 1; i >= 0; i--)
        {
            InsertAtTheBegin(ref start, arr[i]);
        }

        var result = FindNLargestElements(start, N);
        Console.Write("Output: ");
        Print(result);
    }
}

// Implement a priority queue for the C# code
public class PriorityQueue<T> where T : IComparable<T>
{
    private List<T> data;
    private Comparison<T> comparison;

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

    public void Enqueue(T item)
    {
        data.Add(item);
        int childIndex = data.Count - 1;
        while (childIndex > 0)
        {
            int parentIndex = (childIndex - 1) / 2;
            if (comparison(data[childIndex], data[parentIndex]) >= 0)
                break;
            T tmp = data[childIndex];
            data[childIndex] = data[parentIndex];
            data[parentIndex] = tmp;
            childIndex = parentIndex;
        }
    }

    public T Dequeue()
    {
        int lastIndex = data.Count - 1;
        T frontItem = data[0];
        data[0] = data[lastIndex];
        data.RemoveAt(lastIndex--);

        int parentIndex = 0;
        while (true)
        {
            int leftChildIndex = parentIndex * 2 + 1;
            if (leftChildIndex > lastIndex)
                break;
            int rightChildIndex = leftChildIndex + 1;
            if (rightChildIndex <= lastIndex && comparison(data[rightChildIndex], data[leftChildIndex]) < 0)
                leftChildIndex = rightChildIndex;
            if (comparison(data[parentIndex], data[leftChildIndex]) <= 0)
                break;
            T tmp = data[parentIndex];
            data[parentIndex] = data[leftChildIndex];
            data[leftChildIndex] = tmp;
            parentIndex = leftChildIndex;
        }
        return frontItem;
    }

    public int Count
    {
        get { return data.Count; }
    }
}


// This code is contributed by shivamgupta310570