Ejemplo n.º 1
0
        public void DeleteLookup()
        {
            DynamicArray <int> da = new DynamicArray <int>();

            da.Append(1);
            da.Append(2);
            da.Append(3);
            da.Append(4);
            Assert.Equal(4, da.Length);
            Assert.Equal(1, da[0]);
            Assert.Equal(2, da[1]);
            Assert.Equal(3, da[2]);
            Assert.Equal(4, da[3]);

            da.Delete(1);
            Assert.Equal(3, da.Length);
            Assert.Equal(1, da[0]);
            Assert.Equal(3, da[1]);
            Assert.Equal(4, da[2]);

            da.Delete(2);
            Assert.Equal(2, da.Length);
            Assert.Equal(1, da[0]);
            Assert.Equal(3, da[1]);

            da.Delete(0);
            Assert.Equal(1, da.Length);
            Assert.Equal(3, da[0]);

            da.Delete(0);
            Assert.Equal(0, da.Length);
        }
Ejemplo n.º 2
0
    static void Main(string[] args)
    {
        DynamicArray <int> d = new DynamicArray <int>();

        d.Append(3);
        d.Append(1);
        d.Append(1);
        d.Append(2);

        Console.WriteLine(d.arr[0]);
        Console.WriteLine(d.arr[1]);
        Console.WriteLine(d.get(2));
        Console.WriteLine(d.get(3));
        d.set(2, 7);

        //   d.arr = null;    // no permitido porque es privado
        d.Append(3);

        DynamicArray <string> B = new DynamicArray <string>();

        B.Append("Hello");
        B.Append("World");
        Console.WriteLine(B.arr[0] + " " + B.arr[1]);



        Console.Read();

        /*
         * long startTime = DateTime.Now.Ticks;
         * Console.WriteLine(startTime);
         * const int N = 100000000;
         * for (int n = 1; n <= N; n++)
         *  d.Append(n);
         * long endTime = DateTime.Now.Ticks;
         * Console.WriteLine("Termino");
         * Console.WriteLine(endTime);
         * Console.WriteLine("Duracion: {0}", (endTime - startTime) / 10000);
         * Console.Read();
         *
         * List<int> A = new List<int>();
         * A.Add(1);
         */
    }
Ejemplo n.º 3
0
        public void UpdateLookup()
        {
            DynamicArray <int> da = new DynamicArray <int>();

            da.Append(1);
            da.Append(2);
            da.Append(3);
            da.Append(4);
            Assert.Equal(4, da.Length);
            Assert.Equal(1, da[0]);
            Assert.Equal(2, da[1]);
            Assert.Equal(3, da[2]);
            Assert.Equal(4, da[3]);

            da[0] = 99;
            Assert.Equal(4, da.Length);
            Assert.Equal(99, da[0]);
            Assert.Equal(2, da[1]);
            Assert.Equal(3, da[2]);
            Assert.Equal(4, da[3]);

            da[3] = 98;
            Assert.Equal(4, da.Length);
            Assert.Equal(99, da[0]);
            Assert.Equal(2, da[1]);
            Assert.Equal(3, da[2]);
            Assert.Equal(98, da[3]);

            da[1] = 97;
            Assert.Equal(4, da.Length);
            Assert.Equal(99, da[0]);
            Assert.Equal(97, da[1]);
            Assert.Equal(3, da[2]);
            Assert.Equal(98, da[3]);

            da[2] = 96;
            Assert.Equal(4, da.Length);
            Assert.Equal(99, da[0]);
            Assert.Equal(97, da[1]);
            Assert.Equal(96, da[2]);
            Assert.Equal(98, da[3]);
        }
Ejemplo n.º 4
0
        public static void DoTest()
        {
            var dynamicArray = new DynamicArray <long>();

            for (long i = 1; i < 100000; ++i)
            {
                dynamicArray.Append(i);
            }

            Assert.Equal(99999, dynamicArray.ItemsCount);
            Assert.Equal(1, dynamicArray[0]);
            Assert.Equal(99999, dynamicArray[99998]);
        }
Ejemplo n.º 5
0
        public void ExpandingCapacity()
        {
            DynamicArray <int> da = new DynamicArray <int>();

            Assert.Equal(1, da.Capacity);

            da.Append(1);
            Assert.Equal(1, da.Length);
            Assert.Equal(1, da.Capacity);

            da.Append(2);
            Assert.Equal(2, da.Length);
            Assert.Equal(2, da.Capacity);

            da.Append(3);
            Assert.Equal(3, da.Length);
            Assert.Equal(4, da.Capacity);

            da.Append(4);
            Assert.Equal(4, da.Length);
            Assert.Equal(4, da.Capacity);

            da.Append(5);
            Assert.Equal(5, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Append(6);
            Assert.Equal(6, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Append(7);
            Assert.Equal(7, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Append(8);
            Assert.Equal(8, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Append(9);
            Assert.Equal(16, da.Capacity);
        }
Ejemplo n.º 6
0
        public void BulkAppendDelete()
        {
            DynamicArray <int> da = new DynamicArray <int>();

            for (int i = 0; i < 1000000; i++)
            {
                da.Append(i);
            }

            for (int i = 999999; i >= 0; i--)
            {
                da.Delete(i);
            }

            Assert.Equal(0, da.Length);
            Assert.Equal(1, da.Capacity);
        }
Ejemplo n.º 7
0
        public void ShrinkingCapacity()
        {
            DynamicArray <int> da = new DynamicArray <int>();

            for (int i = 0; i < 8; i++)
            {
                da.Append(i);
            }
            Assert.Equal(8, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(7, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(6, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(5, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(4, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(3, da.Length);
            Assert.Equal(8, da.Capacity);

            da.Delete(0);
            Assert.Equal(2, da.Length);
            Assert.Equal(4, da.Capacity);

            da.Delete(0);
            Assert.Equal(1, da.Length);
            Assert.Equal(2, da.Capacity);

            da.Delete(0);
            Assert.Equal(0, da.Length);
            Assert.Equal(1, da.Capacity);
        }