C# ArrayList.Add() overwriting previous objects on add

I have written a simple method that receives a Generic that I wish to place into an ArrayList using the ArrayList.Add() method. However I have discovered that when I go add a new item with the same type as previous items in the ArrayList this new item overwrites the previous items individual properties.

Here's the code its pretty basic and rather embarrassingly I can't seem to rectify this overwriting problem.

public class ChromosomeTree<T>
{
    private GeneNode<T> root;
    private ArrayList children = new ArrayList();
    private int depMax;

    string stemp;

    public ChromosomeTree()
    {
        root = null;
    }

    public virtual void Clear()
    {
        root = null;
    }

    public GeneNode<T> Root
    {
        get
        {
            return root;
        }
        set
        {
            root = value;
        }
    }

    public int MaxDepth
    {
        get
        {
            return depMax;
        }
        set
        {
            depMax = value;
        }
    }

    public ArrayList Children
    {
        get
        {
            return children;
        }
    }

    public GeneNode<T> lastChild()
    {
        return (GeneNode<T>)this.Children[this.Children.Count - 1];
    }

    public void addFull(GeneNode<T> node)
    {
        //check if the chromosome tree has a root if not add the first node as the chromosomes root

        if (this.Root == null)
        {
            this.Root = node;
            children.Add(node);
            stemp += " " + node.Value;
        }
        else
        {
            for (int i = 0; i <= this.Children.Count - 1; i++)
            {
                GeneNode<T> parent = (GeneNode<T>)this.Children[i];

                //check to ensure maxDepth of chromosome tree is not exceeded
                if (parent.Depth != this.MaxDepth)
                {
                    //check to see if the current node stil has room for another node to be added to it
                    if ((parent.Children == null) || (parent.Children[1] == null))
                    {
                        children.Add(node);
                        parent.Add(node);

                        stemp += " " + node.Value;

                        break;
                    }
                }
                else
                {
                    break;
                }
            }
        }
    }

    public override string ToString()
    {
        string chromosome = String.Empty;

        foreach(GeneNode<Gene> gene in this.Children)
        {
            chromosome += " " + gene.Value.GeneValue.ToString();
        }

        return chromosome;
    }
}

Im pretty sure its a simple mistake but ive looked at this for so long I cant see the wood from the trees. Any thoughts would be greatly appreciated.

Many thanks in advance.

Luke

here is the code that utilises the this class.

EDIT : THE OVERWRITE HAPPENS WHEN THE METHOD IS CALLED NOT AFTER THE METHOD HAS EXECUTED ITS LOGIC

 class SimpleChromosome
{
    Random rand = new Random();

    Gene funcGene = new Gene();
    Gene termGene = new Gene();

    private string sChromosome;

    private int currentdepth;

    private string grownChromosome()
    {
        return sChromosome;
    }

    public ChromosomeTree<Gene> fullChromosome()
    {
        ChromosomeTree<Gene> chromosone = new ChromosomeTree<Gene>();
        //chromosone.MaxDepth = rand.Next(1, 5);
        chromosone.MaxDepth = 1;

        int maxGenes = (int)Math.Pow(2, chromosone.MaxDepth + 1) - 1;

        for (int i = 0; i <= chromosone.MaxDepth; i++)
        {
            int numNodesForLevel = (int)Math.Pow(2, i);
            int numNodesOnLevel = 0;

            for (int j = 0; j < numNodesForLevel; j++)
            {
                if (currentdepth != chromosone.MaxDepth)
                {
                    funcGene.GenerateValue(GeneType.Function);
                    GeneNode<Gene> geneNode = new GeneNode<Gene>(funcGene);
                    sChromosome += " " + geneNode.Value;
                    chromosone.addFull(geneNode);

                    numNodesOnLevel++;
                }
                else
                {
                    termGene.GenerateValue(GeneType.Terminal);
                    GeneNode<Gene> geneNode = new GeneNode<Gene>(termGene);
                    sChromosome += " " + geneNode.Value;
                    chromosone.addFull(geneNode);

                    numNodesOnLevel++;
                }

                if ((numNodesForLevel == numNodesOnLevel) && (currentdepth != chromosone.MaxDepth))
                {
                    currentdepth++;
                }
            }
        }
        currentdepth = 0;

        //Console.WriteLine("Before ADD :" + sChromosome);

        sChromosome = "";

        return chromosone;
    }
}