C Array loop through

Only indirectly:

#include <stdio.h>

int main(void)
{
    int i, intArray[10000];
    int active[10000];
    int n_active = 0;
    intArray[334] = 30;
    active[n_active++] = 334;
    intArray[563] = 50;
    active[n_active++] = 563;
    intArray[989] = 90;
    active[n_active++] = 989;

    for (i = 0; i < n_active; i++)
      printf("%d\n", intArray[active[i]]);
    return 0;
}

Or, more succinctly but not more clearly:

#include <stdio.h>

int main(void)
{
    int i, intArray[10000];
    int active[10000];
    int n_active = 0;
    intArray[active[n_active++]=334] = 30;
    intArray[active[n_active++]=563] = 50;
    intArray[active[n_active++]=989] = 90;

    for (i = 0; i < n_active; i++)
      printf("%d\n", intArray[active[i]]);
    return 0;
}

Both of these programs will suffer if there's more than one assignment to the same index (that index will be stored in the active array twice). As it stands, it also doesn't check for overflow of the active array (but that shouldn't be a problem; the hypothesis is that only a few of the rows are populated), and the indexes are stored in the order that they're presented — not in key order. All these defects can be fixed, but take more code (it would probably need to be a function or two).

You can do something like this

# include <stdio.h>
int totalElements = 0;
struct 
{
   int index, data;
} Data[10000];

void addElement(int index, int data)
{
   Data[totalElements].data = data;
   Data[totalElements++].index = index;
}

main()
{
   int i;
   addElement(334, 30);
   addElement(563, 50);
   addElement(989, 90);
   for (i = 0; i < totalElements; i++)
   {
      printf("%d %d\n", Data[i].data, Data[i].index);
   }
}

Output

30 334
50 563
90 989

This also suffers the same limitations Jonathan Leffler mentioned.

EDIT

# include <stdio.h>
int totalElements = 0;
struct
{
   int index, currentElement = 0, data[100];
} Data[10000];

void addElement(int index, int data)
{
   int i;
   for (i = 0; i < totalElements; i++)
   {
      if (Data[i].index == index)
      {
         Data[i].data[Data[i].currentElement++] = data;
         return;
      }
   }
   Data[totalElements].data[Data[totalElements].currentElement++] = data;
   Data[totalElements++].index = index;
}

main()
{
   int i, j;
   addElement(334, 30);
   addElement(334, 40);
   addElement(563, 50);
   addElement(563, 60);
   addElement(989, 80);
   addElement(989, 90);
   for (i = 0; i < totalElements; i++)
   {
      for (j = 0; j < Data[i].currentElement; j++)
      {
         printf("%d %d\n", Data[i].index, Data[i].data[j]);
      }
   }
}

Output

334 30
334 40
563 50
563 60
989 80
989 90

Using this idea you can overcome the limitations mentioned by Jonathan Leffler.

Perhaps you could use a different data structure, like a linked list. Each node in the list could have two int values, one could be the index and the other the value. The linked list would then only contain indicies which have been assigned (and you could also have value==0, if that is somehow different to the normal, unassigned index).

The other alternative would be to use something like a Dictionary structure. There are probably Dictionary implementations for C - I would say though, if C++ is available maybe you should use it instead (unless you are specifically trying to learn or are constrained to C) - C++ has many data types available straight out of the box.