/// <summary>
        /// Seznam predstavi z nizom oblike [e0, e1, ..., en].
        /// </summary>
        /// <returns>Predstavitev seznama z nizom.</returns>
        public override string ToString()
        {
            if (glava == null)
            {
                return("[]");
            }
            string predstavitev = "";
            Clen   trenutni     = glava;

            while (trenutni != null)
            {
                predstavitev += ", " + trenutni.Vsebina.ToString();
                trenutni      = trenutni.Naslednik;
            }
            return("[" + predstavitev.Substring(2) + "]");
        }
        /// <summary>
        /// Doda podani element na izbrano mesto v seznamu.
        /// </summary>
        /// <param name="vrednost">Element, ki ga dodajamo.</param>
        /// <param name="mesto">Mesto, kamor dodajamo element.</param>
        public void Dodaj(T vrednost, int mesto)
        {
            Dolzina++;
            Clen novi = new Clen(vrednost);

            if (mesto == 0)
            {
                novi.Naslednik = glava;
                glava          = novi;
            }
            else
            {
                Clen prednik = ClenNaMestu(mesto - 1);
                novi.Naslednik    = prednik.Naslednik;
                prednik.Naslednik = novi;
            }
        }
        /// <summary>
        /// Vrne člen na določenem mestu.
        /// </summary>
        /// <param name="mesto"></param>
        private Clen ClenNaMestu(int mesto)
        {
            if (glava == null)
            {
                throw new Exception("Seznam je prekratek.");
            }
            Clen kandidat = glava;

            while (mesto > 0)
            {
                kandidat = kandidat.Naslednik;
                if (kandidat == null)
                {
                    throw new Exception("Seznam je prekratek.");
                }
                mesto--;
            }
            return(kandidat);
        }
Example #4
0
        void DoDyn() // Dynamic huffman encoding, the most complex case, RFC1951 page 12.
        {
            uint nLitCode = 257 + GetBits(5), nDistCode = 1 + GetBits(5), nLenCode = 4 + GetBits(4);

            for (uint i = 0; i < nLenCode; i += 1)
            {
                ClenLen[ClenAlphabet[i]] = (byte)GetBits(3);
            }
            for (uint i = nLenCode; i < 19; i += 1)
            {
                ClenLen[ClenAlphabet[i]] = 0;
            }
            Clen.MakeTree(ClenLen, 19);

            Plenc = 0; uint carry = GetLengths(LitLen, nLitCode, 0); GetLengths(DistLen, nDistCode, carry);
            Lit.MakeTree(LitLen, nLitCode);
            Dist.MakeTree(DistLen, nDistCode);

            while (true)
            {
                uint x = Lit.Decode(this);
                if (x < 256)
                {
                    OB.Add((byte)x);
                }
                else if (x == 256)
                {
                    break;
                }
                else
                {
                    x -= 257;
                    uint length   = MatchOff[x] + GetBits(MatchExtra[x]);
                    uint dc       = Dist.Decode(this);
                    uint distance = DistOff[dc] + GetBits(DistExtra[dc]);
                    if (TraceLevel > 1)
                    {
                        System.Console.WriteLine("Copy at " + OB.Count + " length=" + length + " distance=" + distance);
                    }
                    OB.Copy(distance, length);
                }
            }
        } // end DoDyn
 /// <summary>
 /// Odstrani element na izbranem mestu v seznamu.
 /// </summary>
 /// <param name="mesto"></param>
 public void Odstrani(int mesto)
 {
     if (glava == null)
     {
         throw new Exception("Seznam ni dovolj dolg.");
     }
     if (mesto == 0)
     {
         glava = glava.Naslednik;
     }
     else
     {
         Clen prednik = ClenNaMestu(mesto - 1);
         if (prednik.Naslednik == null)
         {
             throw new Exception("Seznam ni dovolj dolg.");
         }
         prednik.Naslednik = prednik.Naslednik.Naslednik;
     }
     Dolzina--;
 }