using System;
using System.Collections;

public class Coll {
 public static void Main() {
  ArrayList al = new ArrayList();
  int st = Environment.TickCount;
  for(int i = 0; i < 1000000; i++) {
   al.Insert(0,new object());
   if(al.Count > 1000)
    al.RemoveAt(al.Count-1);
  }
  Console.WriteLine(Environment.TickCount-st);

  Queue q = new Queue();
  st = Environment.TickCount;
  for(int i = 0; i < 1000000; i++) {
   q.Enqueue(new object());
   if(q.Count > 1000)
    q.Dequeue();
  }
  Console.WriteLine(Environment.TickCount-st);
 }
}

1859
188

class Node
{
   publib Noden pNext = null;
   SomeDataType SomeData;
};
...

Node Root = new Node();

Node pNewNode = Root;
for(int i = 0; i < 100; i++)
{
  Node pTmp = new Node();
  pNewNode.pNext = pTmp;
  pNewNode = pTmp;
}

VD>class Node
VD>{
VD>   publib Noden pNext = null;
VD>   SomeDataType SomeData;
VD>};
VD>...

VD>Node Root = new Node();

VD>Node pNewNode = Root;
VD>for(int i = 0; i < 100; i++)
VD>{
VD>  Node pTmp = new Node();
VD>  pNewNode.pNext = pTmp;
VD>  pNewNode = pTmp;
VD>}
VD>

import java.util.*;

public class Coll {
 public static void main(String[] args) {
  ArrayList al = new ArrayList();
  long st = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++) {
   al.add(0,new Object());
   if(al.size() > 1000)
    al.remove(al.size()-1);
  }
  System.out.println(System.currentTimeMillis()-st);

  LinkedList q = new LinkedList();
  st = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++) {
   q.addFirst(new Object());
   if(q.size() > 1000)
    q.removeLast();
  }
  System.out.println(System.currentTimeMillis()-st);
 }
}

using System;
using System.Collections;

class ArrayStack {
 private ArrayList al = new ArrayList();
 public void Push(object obj) {
  al.Add(obj);
 }
 public object Pop() {
  object obj = al[al.Count-1];
  al.RemoveAt(al.Count-1);
  return obj;
 }
}

public class Test {
 private const int ITER_COUNT = 1000000;

 public static void Main() {
  ArrayStack ars = new ArrayStack();
  int st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Push(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Push(new object());
   ars.Pop();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Pop();
  }
  Console.WriteLine(Environment.TickCount-st);

  Stack s = new Stack();
  st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Push(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Push(new object());
   s.Pop();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Pop();
  }
  Console.WriteLine(Environment.TickCount-st);

  Queue q = new Queue();
  st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Enqueue(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Enqueue(new object());
   q.Dequeue();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Dequeue();
  }
  Console.WriteLine(Environment.TickCount-st);
 }
}

using System;
using System.Collections;

namespace Lists
{
  class ArrayStack 
  {    
    public ArrayStack(int Capacity){ al = new ArrayList(Capacity); }
    private ArrayList al;
    public void Push(object obj)
    {
      al.Add(obj);
    }
    public object Pop()
    {
      object obj = al[al.Count-1];
      al.RemoveAt(al.Count-1);
      return obj;
    }
  }

  class IntArrayStack 
  {  
    public IntArrayStack(int Capacity){ this.Capacity = Capacity; }
    int m_iCapacity;
    public int Capacity
    {
      get{ return m_iCapacity; }
      set
      {
        if(value < 0)
          throw new Exception("Capacity не может быть меньше нул!");
        m_Array = new int[value];
        m_iCapacity = value;
      }
    }
    public void Grow(){ Capacity = Capacity * 2; }

    int m_iCount = 0;
    public int Count{ get{ return m_iCount; } }

    private int[] m_Array;
    public void Push(int obj)
    {
      if(m_iCount >= m_iCapacity)
        Grow();
      m_Array[m_iCount] = obj;
      m_iCount++;
    }
    public int Pop()
    {
      m_iCount--;
      return m_Array[m_iCount];
    }
  }

  public class Test
  {
    private const int Capacity = 1100000;
    private const int ITER_COUNT = 1000000;

    static void StackTest()
    {
      Stack s = new Stack(Capacity);
      int st = Environment.TickCount;
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        s.Push(new object());
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        s.Push(new object());
        s.Pop();
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        s.Pop();
      }
      Console.WriteLine("Stack: " + (Environment.TickCount - st));
    }
    static void ArrayStackTest()
    {
      ArrayStack ars = new ArrayStack(Capacity);
      int st = Environment.TickCount;
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        ars.Push(new object());
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        ars.Push(new object());
        ars.Pop();
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        ars.Pop();
      }
      Console.WriteLine("ArrayStack: " + (Environment.TickCount - st));
    }
    static void IntArrayStackTest()
    {
      IntArrayStack  iars = new IntArrayStack(Capacity);
      int st = Environment.TickCount;
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        iars.Push(i);
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        iars.Push(i);
        iars.Pop();
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        iars.Pop();
      }
      Console.WriteLine("IntArrayStack: " + (Environment.TickCount - st));
    }
    static void QueueTest()
    {
      Queue q = new Queue(Capacity);
      int st = Environment.TickCount;
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        q.Enqueue(new object());
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        q.Enqueue(new object());
        q.Dequeue();
      }
      for(int i = 0; i < ITER_COUNT; i++) 
      {
        q.Dequeue();
      }
      Console.WriteLine("Queue: " + (Environment.TickCount - st));
    }

    public static void Main() 
    {
      QueueTest();
      StackTest();
      ArrayStackTest();
      IntArrayStackTest();

      Console.WriteLine("\nStep 2...");
      QueueTest();
      StackTest();
      ArrayStackTest();
      IntArrayStackTest();

      Console.WriteLine("\nStep 3...");
      IntArrayStackTest();
      ArrayStackTest();
      QueueTest();
      StackTest();

      Console.WriteLine("\nPress Enter to exit...");
      Console.ReadLine();
    }
  }

}

Queue: 1172
Stack: 601
ArrayStack: 630
IntArrayStack: 61

Step 2...
Queue: 881
Stack: 581
ArrayStack: 611
IntArrayStack: 60

Step 3...
IntArrayStack: 50
ArrayStack: 561
Queue: 891
Stack: 561

using System;
using System.Collections;

class ArrayStack {
 private ArrayList al = new ArrayList();
 public void Push(object obj) {
  al.Add(obj);
 }
 public object Pop() {
  object obj = al[al.Count-1];
  al.RemoveAt(al.Count-1);
  return obj;
 }
}

public class Test {
 private const int ITER_COUNT = 1000000;

 public static void Main() {
  ArrayStack ars = new ArrayStack();
  int st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Push(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Push(new object());
   ars.Pop();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   ars.Pop();
  }
  Console.WriteLine(Environment.TickCount-st);
//Изменено здесь
  GC.Collect();

  Stack s = new Stack();
  st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Push(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Push(new object());
   s.Pop();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   s.Pop();
  }
  Console.WriteLine(Environment.TickCount-st);
//И здесь
  GC.Collect();

  Queue q = new Queue();
  st = Environment.TickCount;
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Enqueue(new object());
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Enqueue(new object());
   q.Dequeue();
  }
  for(int i = 0; i < ITER_COUNT; i++) {
   q.Dequeue();
  }
  Console.WriteLine(Environment.TickCount-st);
 }
}

int outparam = 1;
Func1(outparam);
//do something with outparam
Func2(outparam);
//do something with outparam
Func3(outparam);
//do something with outparam
Func4(outparam);