Removing alternate elements in a List<T>

Question

What is the most efficient way to remove alternate (odd indexed or even indexed) elements in an List<T> without using a place holder list variable?

Also it would be appreciated if you could mention the cost with each of your answer.

I'm looking for an efficient way to do this

Thanks in advance

Answer 1

I'm not sure what you mean by alternate but if you mean "every other item" the following code will work. It will start by removing the 2nd element, then the 4th, and so on

List<T> list = GetTheList();
int i = 1;
while ( i < list.Count ) {
  list.RemoveAt(i);
  i++;
}

Answer 2

If you call RemoveAt for every item you remove, you will be moving a lot of data. The most efficient is to move the items together that you want to keep, then remove the unused items at the end:

int pos = 0;
for (int i = 0; i < values.Count; i += 2, pos++) {
 values[pos] = values[i];
}
values.RemoveRange(pos, values.Count - pos);

Edit:
This method will process a list of a million ints in 15 ms. Using RemoveAt it will take over three minutes...

Edit2:
You could actually start with pos=1 and i=2 (or 3), as the first item doesn't have to be copied to itself. This makes the code a bit less obvious though.

Answer 3

Just for consideration of a solution that creates a new list, with a list old you could do this:

var newList = old.Where((_, i) => i%2 != 0).ToList();

or, obviously

var newList = l.Where((_, i) => i%2 == 0).ToList();

depending which alternation you choose.

EDIT

The answer is quite a bit quicker. If you read something else here, it's because I measured on a weekend and weekend's brain is funny. :( The closure solution is about 40% quicker while the answer is app. 2 orders of magnitude faster. I suppose it will really depend how big your list becomes!

Answer 4

And another option, similar to Frank's one, but with usage of closures. And it is quicker than Frank's version.

bool isEven = true;            
var newList = list.Where(x => isEven = !isEven).ToList();

Answer 5

for (int i=myList.length-1; i >= 0; i--)
  if (i % 2 == 0)
    myList.Remove(myList[i]);

Answer 6

I would use the standard pattern generally used for STL containers. Do a remove followed by an erase.

This way you will not confuse people that are used to seeing this pattern.

template<typename T>
struct RemoveEven
{
    RemoveEven():count(0)   {}
    bool operator()(T const&)
    {
        bool    result  =  count%2 == 0;
        count++;
        return result;
    }
    private:
        std::size_t count;
};
int main()
{
    std::list<int>  a;
    a.erase(std::remove_if(a.begin(),a.end(),RemoveEven<int>()),a.end());

}

Answer 7

Obviously usage dependent, but you could have a wrapper IList that multiplies the index you give it by 2, and reports the length of the list to be 1/2 (details elided). This is O(1).

Answer 8

The way to Nirvana is paved with deferred execution. Or something.

    public static IEnumerable<T> AlternateItems<T>(this IEnumerable<T> source)
    {
        while (source.Any())
        {
            yield return source.First();

            source = source.Skip(1);

            if (source.Any()) source = source.Skip(1);                
        }
    }

This works for all sequences, not just IList<>. The cost of iteration is deferred until iteration, which may be a big win if, in the end, you don't need to touch all the elements in the list.

In my simple tests, the performance when you iterate over the whole list is not very good, so be sure to profile your real situation.