Why does order matter?

Question

Why is it that if say a deriv is dealt with followed by another deriv the second is missed? why is the order of the term important for this code to work?
public void removeIdenticalTerms(String [][] goldStandard, String [][] testModel, int numRows, int goldRows, int columns)
         * Compare all terms in the goldStandard with those in testModel,
         * if any are found remove them and shuffleUp
         * This should also remove any deriv operators
         * Then call the next method
         int difference=0;
         for(int i=0; i<goldRows; i++)
             for(int k=0; k<numRows; k++)
                if(goldStandard[0].equals(testModel[k][0]))
//The predicates match so compare the variables
if((goldStandard[i][0].equals("deriv"))||(goldStandard[i][0].equals("m_plus"))||(goldStandard[i][0].equals("minus")))
if((goldStandard[i][1].equals(testModel[k][1]))&&(goldStandard[i][2].equals(testModel[k][2])))
System.out.println("\nA " + goldStandard[i][0] + " has been removed");
//Remove and shuffle up
for(int h=0; h<columns; h++)
goldStandard[i][h] = null;
testModel[k][h]=null;
shuffleUp(goldStandard, i, goldRows, columns);
goldRows--;
shuffleUp(testModel, k, numRows, columns);
numRows--;
else if(goldStandard[i][0].equals("add"))
if((goldStandard[i][1].equals(testModel[k][1]))&&(goldStandard[i][2].equals(testModel[k][2]))&&(goldStandard[i][3].equals(testModel[k][3])))
System.out.println("\nAn " + goldStandard[i][0] + " has been removed");
//Remove and shuffle up
for(int h=0; h<columns; h++)
goldStandard[i][h] = null;
testModel[k][h]=null;
shuffleUp(goldStandard, i, goldRows, columns);
goldRows--;
shuffleUp(testModel, k, numRows, columns);
numRows--;
System.out.println("\nTest Model\n");
for(int g=0; g<numRows; g++)
for(int m=0; m<columns; m++)
if(!(testModel[g][m]== null))
System.out.println(testModel[g][m]);
System.out.println("\nGold Standard\n");
for(int g=0; g<goldRows; g++)
for(int m=0; m<columns; m++)
if(!(goldStandard[g][m]==null))
System.out.println(goldStandard[g][m]);
countOperators(goldStandard, testModel, numRows, goldRows, columns);

Answer 1

Well, here is another instance where I would use collections
(LinkedList or ArrayList).
But if you have to use arrays...
Well, I guess instead of removing all the ones you want to remove
and shuffling them all up, you could store the indeces that you find
then after collecting them all, run the remove and shuffle up for each
index found.
int[] removeThese = new int[goldRows]; //Maybe need to remove all rows!
int currentPlace = 0;
for (int i = //...) {
  for (int k = //...) {
    if (goldRows[ i ][ 0 ].equals(//...)//...) {
      removeThese[currentPlace++] = i;
      //Dont remove or shuffle yet
for (int r = 0; r <= currenPlace; r++) {
  remove(goldRow, removeThese[r], //...);
  shuffleUp(goldRow, removeThese[r], //...);
}As psuedo code...