Question

I can’t figure out a discrepancy between the time it takes for the Contains method to find an element in an ArrayList and the time it takes for a small function that I wrote to do the same thing. The documentation states that Contains performs a linear search, so it’s supposed to be in O(n) and not any other faster method. However, while the exact values may not be relevant, the Contains method returns in 00:00:00.1087087 seconds while my function takes 00:00:00.1876165. It might not be much, but this difference becomes more evident when dealing with even larger arrays. What am I missing and how should I write my function to match Contains‘s performances?

I’m using C# on .NET 3.5.

public partial class Window1 : Window
{
    public bool DoesContain(ArrayList list, object element)
    {
        for (int i = 0; i < list.Count; i++)
            if (list[i].Equals(element)) return true;

        return false;
    }

    public Window1()
    {
        InitializeComponent();

        ArrayList list = new ArrayList();
        for (int i = 0; i < 10000000; i++) list.Add("zzz " + i);

        Stopwatch sw = new Stopwatch();
        sw.Start();

        //Console.Out.WriteLine(list.Contains("zzz 9000000") + " " + sw.Elapsed);
        Console.Out.WriteLine(DoesContain(list, "zzz 9000000") + " " + sw.Elapsed);
    }
}

EDIT:

Okay, now, lads, look:

public partial class Window1 : Window
{
    public bool DoesContain(ArrayList list, object element)
    {
        int count = list.Count;
        for (int i = count - 1; i >= 0; i--)
            if (element.Equals(list[i])) return true;

        return false;
    }


    public bool DoesContain1(ArrayList list, object element)
    {
        int count = list.Count;
        for (int i = 0; i < count; i++)
            if (element.Equals(list[i])) return true;

        return false;
    }

    public Window1()
    {
        InitializeComponent();

        ArrayList list = new ArrayList();
        for (int i = 0; i < 10000000; i++) list.Add("zzz " + i);

        Stopwatch sw = new Stopwatch();
        long total = 0;
        int nr = 100;

        for (int i = 0; i < nr; i++)
        {
            sw.Reset();
            sw.Start();
            DoesContain(list,"zzz");
            total += sw.ElapsedMilliseconds;
        }
        Console.Out.WriteLine(total / nr);


        total = 0;
        for (int i = 0; i < nr; i++)
        {
            sw.Reset();
            sw.Start();
            DoesContain1(list, "zzz");
            total += sw.ElapsedMilliseconds;
        }
        Console.Out.WriteLine(total / nr);


        total = 0;
        for (int i = 0; i < nr; i++)
        {
            sw.Reset();
            sw.Start();
            list.Contains("zzz");
            total += sw.ElapsedMilliseconds;
        }
        Console.Out.WriteLine(total / nr);
    }
  }

I made an average of 100 running times for two versions of my function(forward and backward loop) and for the default Contains function. The times I’ve got are 136 and
133 milliseconds for my functions and a distant winner of 87 for the Contains version. Well now, if before you could argue that the data was scarce and I based my conclusions on a first, isolated run, what do you say about this test? Not does only on average Contains perform better, but it achieves consistently better results in each run. So, is there some kind of disadvantage in here for 3rd party functions, or what?

Answer 1

Using the code below I was able to get the following timings relatively consitently (within a few ms):
1: 190ms DoesContainRev
2: 198ms DoesContainRev1
3: 188ms DoesContainFwd
4: 203ms DoesContainFwd1
5: 199ms Contains

Several things to notice here.

1. This is run with release compiled code from the commandline. Many people make the mistake of benchmarking code inside the Visual Studio debugging environment, not to say anyone here did but something to be careful of.

2. The list[i].Equals(element) appears to be just a bit slower than element.Equals(list[i]).

   using System;
   using System.Diagnostics;
   using System.Collections;
   
   
   namespace ArrayListBenchmark
   {
   class Program
   {
       static void Main(string[] args)
       {
           Stopwatch sw = new Stopwatch();
           const int arrayCount = 10000000;
           ArrayList list = new ArrayList(arrayCount);
           for (int i = 0; i < arrayCount; i++) list.Add("zzz " + i);
       sw.Start();
       DoesContainRev(list, "zzz");
       sw.Stop();
       Console.WriteLine(String.Format("1: {0}", sw.ElapsedMilliseconds));
       sw.Reset();
   
       sw.Start();
       DoesContainRev1(list, "zzz");
       sw.Stop();
       Console.WriteLine(String.Format("2: {0}", sw.ElapsedMilliseconds));
       sw.Reset();
   
       sw.Start();
       DoesContainFwd(list, "zzz");
       sw.Stop();
       Console.WriteLine(String.Format("3: {0}", sw.ElapsedMilliseconds));
       sw.Reset();
   
       sw.Start();
       DoesContainFwd1(list, "zzz");
       sw.Stop();
       Console.WriteLine(String.Format("4: {0}", sw.ElapsedMilliseconds));
       sw.Reset();
   
       sw.Start();
       list.Contains("zzz");
       sw.Stop();
       Console.WriteLine(String.Format("5: {0}", sw.ElapsedMilliseconds));
       sw.Reset();
   
       Console.ReadKey();
   }
   public static bool DoesContainRev(ArrayList list, object element)
   {
       int count = list.Count;
       for (int i = count - 1; i >= 0; i--)
           if (element.Equals(list[i])) return true;
   
       return false;
   }
   public static bool DoesContainFwd(ArrayList list, object element)
   {
       int count = list.Count;
       for (int i = 0; i < count; i++)
           if (element.Equals(list[i])) return true;
   
       return false;
   }
   public static bool DoesContainRev1(ArrayList list, object element)
   {
       int count = list.Count;
       for (int i = count - 1; i >= 0; i--)
           if (list[i].Equals(element)) return true;
   
       return false;
   }
   public static bool DoesContainFwd1(ArrayList list, object element)
   {
       int count = list.Count;
       for (int i = 0; i < count; i++)
           if (list[i].Equals(element)) return true;
   
       return false;
   }
            }
           }