public List<Zdarzenie> Przeciecia(List<Odcinek> S)
        {
            this.wynik = new List<Zdarzenie>();
            this.H = new Harmonogram();
            this.T = new Symbole();

            for (int i = 0; i < S.Count; i++)
            {
                H.insert(new Zdarzenie(S[i].p1, TypZdarzenia.Poczatek, S[i], null));
                H.insert(new Zdarzenie(S[i].p2, TypZdarzenia.Koniec, S[i], null));
            }

            H.Sort();

            while (!H.empty())
            {
                Zdarzenie z = H.pop();
                Odcinek odcE = z.getOdcinek1();

                if (z.getType() == TypZdarzenia.Poczatek)
                {
                    T.insert(odcE, S.IndexOf(odcE));
                    int index = T.getIndex(odcE);

                    Odcinek odcA = T.above(index);
                    Odcinek odcB = T.below(index);

                    Zdarzenie e1 = odcE.ZwrocZdarzenie(odcA);
                        
                    if (e1.getType() == TypZdarzenia.Przeciecie)//czy przecina
                    {
                        e1.setOdcinek1(z.getOdcinek1());
                        int iterator = index + 1;
                        if (iterator == T.countT()) { iterator = 0; }
                        e1.setOdcinek2(S[T.iteratorIS(iterator)]);
                        H.insert(e1);
                    }

                    Zdarzenie e2 = odcE.ZwrocZdarzenie(T.below(index));
                    if (e2.getType() == TypZdarzenia.Przeciecie)//czy przecina
                    {
                        e2.setOdcinek1(z.getOdcinek1());
                        e2.setOdcinek2(S[T.iteratorIS(index - 1)]);
                        H.insert(e2);
                    }
                }

                if (z.getType() == TypZdarzenia.Koniec)
                {
                    int i = T.getIndex(odcE);
                    Odcinek odcA = T.above(i);
                    Odcinek odcB = T.below(i);

                    Zdarzenie e = T.above(i).ZwrocZdarzenie((T.below(i)));
                    if (e.getType() == TypZdarzenia.Przeciecie)//czy przecina
                    {
                        e.setOdcinek1(S[T.iteratorIS(i - 1)]);
                        int iterator = i + 1;
                        if (iterator == T.countT()) { iterator = 0; }
                        e.setOdcinek2(S[T.iteratorIS(iterator)]);
                        H.insert(e);
                        T.delete(i);
                    }
                }

                if (z.getType() == TypZdarzenia.Przeciecie)
                {
                    wynik.Add(z);
                    
                    int i = T.getIndex(odcE);
                    Odcinek odcA = T.above(i);

                    if (T.above(i) != null)
                    {
                        Zdarzenie e = z.getOdcinek2().ZwrocZdarzenie(odcA);
                        if (e.getType() == TypZdarzenia.Przeciecie)
                        {
                            e.setOdcinek1(z.getOdcinek2());
                            int iterator = i + 1;
                            if (iterator == T.countT()) { iterator = 0; }
                            e.setOdcinek2(S[T.iteratorIS(iterator)]);
                            H.insert(e);
                        }

                        T.delete(i);
                        T.delete(T.getIndex(z.getOdcinek2()));

                        T.insert(z.getOdcinek2(), S.IndexOf(z.getOdcinek2()));
                        T.insert(z.getOdcinek1(), S.IndexOf(z.getOdcinek1()));
                    }
                }
               
            }
            return wynik;
        }


class Symbole
    {
        List<Odcinek> T;
        List<int> iteratorS;

        public Symbole()
        {
            T = new List<Odcinek>();
            iteratorS = new List<int>();
        }

        public int countT() { return T.Count; }

        public void insert(Odcinek s, int i) 
        { 
            T.Add(s);
            iteratorS.Add(i); 
        }

        public int iteratorIS(int index) 
        { 
            return iteratorS[index];
        }

        public int getIndex(Odcinek s)
        {
            for (int i = 0; i < T.Count; i++)
            {
                if (T[i].Equals(s)) 
                { 
                    return i; 
                }
            }
            return -1;
        }

        public Odcinek above(int i)
        {
            if (T.Count == 0) return null;
            else return T[(i + 1) % T.Count];
        }

        public Odcinek below(int i)
        {
            if ((i - 1) > -1) return T[i - 1];
            return null;
        }

        public void delete(int i)
        {
            T.RemoveAt(i);
            iteratorS.RemoveAt(i);
        }