drzewo turniejowe

class TournamentTree<K, V> : PriorityQueue<K, V> where K : IComparable
    {
        private Element<K, V>[] players; //przechowuje zawodnikow
        private int[] tree; //przechowuje indeksy do zwyciezcow poszczegolnych meczow,
        //tj. tree[0] to zwyciezca calego turnieju, tree[1],tree[2] zwyciezcy polfinalow      
        private int numberOfElements;

        private int Left(int n)
        {
            return (2 * n)+1;
        }
        private int Right(int n)
        {
            return (2 * n) + 2;
        }
        public void Initialize()
        {
            Initialize(1024);
        }
        public TournamentTree()
        {
            Initialize();
        }
        public TournamentTree(int i)
        {
            Initialize(i);
        }
        public void Initialize(int i)
        {
            players = new Element<K, V>[i];
            tree = new int[i-1];
            numberOfElements = 0;

        }
        

        public void Insert(V v, K key)
        {
            Element<K, V> e = new Element<K, V>(key, v);

            if (numberOfElements == players.Length) // ewentualnie zwiekszanie pojemnosci
            {
                Element<K, V>[] b = new Element<K, V>[numberOfElements+1];
                int[] a = new int[numberOfElements];
                for (int i = 0; i < numberOfElements+1; i++)
                {
                    b[i] = players[i];
                    a[i-1] = tree[i-1];
                }
                players = b;
                tree = a;
            }
            players[numberOfElements++] = e;

            Replay();
        }
        public Element<K, V> DeleteMin()
        {
            if (numberOfElements == 0) return null;
            Element<K, V> result = new Element<K, V>();
            result = players[tree[0]];
            Replay();
            return result;
        }

           

        private void Replay()
        {
            for (int i = numberOfElements; i > 1; i -= 2)
            {

                if (players[i - 2].key.CompareTo(players[i - 1].key) > 0)
                    tree[tree.Length-players.Length+i] = i;
                else
                    tree[tree.Length-players.Length+i] = i - 1;
            }


            int tmp = numberOfElements / 2;
            while (tmp != 0)
            {
                for (int i=(tmp*2-1)-tmp-1; i>tmp/4; --i)
                {

                    if (players[Right(i)].key.CompareTo(players[Left(i)].key) > 0)
                        tree[i] = Left(i);
                    else
                        tree[i] = Right(i);
                }
            }
            tmp /= 2;
        }

co jest nie tak z tym kodem, bo nawet dla kilku elementów czas trwania jest mega długi..

1. po przekopiowaniu kodu oraz jego odpaleniu dostajesz OutOfStalkException() Jest to wynik błędnej klasy Insert(). Implementujesz zbiór (tablicę) elementów jako Const.Interface<x>, a później używasz odwołań jak w przypadku zwykłych klas.

2. zmodyfikuj kod tak, aby zamiast interfejsu używać zwykłych tablic.