zaddd

using System;

namespace Zad2
{
    interface IKolejkaPriorytetowa
    {
        int Wielkość
        {
            get;
            set;
        }
        void Wstaw(int wartość);
        int Usun();
    }

    class KolejkaPriorytetowaMin : IKolejkaPriorytetowa
    {
        public int Wielkość { get; set; }
        int[] dane;

        public KolejkaPriorytetowaMin(int rozmiar)
        {
            dane = new int[rozmiar];
            Wielkość = 0;
        }

        public int getRightChild(int index)
        {
            if ((((2 * index) + 1) < dane.Length && (index >= 1)))
                return (2 * index) + 1;
            return -1;
        }

        public int getLeftChild(int index)
        {
            if (((2 * index) < dane.Length && (index >= 1)))
                return 2 * index;
            return -1;
        }

        public int getParent(int index)
        {
            if ((index > 1) && (index < dane.Length))
            {
                return index / 2;
            }
            return -1;
        }

        public void minHeapify(int index)
        {
            int leftChildIndex = getLeftChild(index);
            int rightChildIndex = getRightChild(index);

            int smallest = index;

            if ((leftChildIndex <= Wielkość) && (leftChildIndex > 0))
            {
                if (dane[leftChildIndex] < dane[smallest])
                {
                    smallest = leftChildIndex;
                }
            }

            if ((rightChildIndex <= Wielkość && (rightChildIndex > 0)))
            {
                if (dane[rightChildIndex] < dane[smallest])
                {
                    smallest = rightChildIndex;
                }
            }

            if (smallest != index)
            {
                int temp;

                temp = dane[smallest];
                dane[smallest] = dane[index];
                dane[index] = temp;
                minHeapify(smallest);
            }
        }

        public void buildMinHeap()
        {
            for (int i = Wielkość / 2; i >= 1; i--)
            {
                minHeapify(i);
            }
        }

        public int Usun()
        {
            int min = dane[1];
            dane[1] = dane[Wielkość];
            Wielkość--;
            minHeapify(1);
            return min;
        }

        public void decreaseKey(int index, int key)
        {
            dane[index] = key;
            while ((index > 1) && (dane[getParent(index)] > dane[index]))
            {
                int temp;
                temp = dane[getParent(index)];
                dane[getParent(index)] = dane[index];
                dane[index] = temp;
                index = getParent(index);
            }
        }

        public void Wstaw(int wartość)
        {
            Wielkość++;
            dane[Wielkość] = 1000;
            decreaseKey(Wielkość, wartość);
        }

        public void Wypisz()
        {
            for (int i = 1; i <= Wielkość; i++)
            {
                Console.Write(dane[i] + " ");
            }
            Console.WriteLine();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            KolejkaPriorytetowaMin min = new KolejkaPriorytetowaMin(20);
            min.buildMinHeap();
            min.Wstaw(1);
            min.Wstaw(5);
            min.Wstaw(2);
            min.Wstaw(6);
            min.Wstaw(4);
            min.Wstaw(7);
            min.Wstaw(11);
            min.Wypisz();
            min.Usun();
            min.Wypisz();
            min.Usun();
            min.Wypisz();
            min.Usun();
            min.Wypisz();

            Console.ReadKey();
        }
    }
}