I use a "flood fill" pathfinding for my mobile RTS.
(where I need fast calculations, for many units)

Its a bit similar to A*, but it has no heuristics.

Here how it works:

I have a gridbased level, with passable and inpassable areas.
(works with node-based pathfinding too)

When the pathfinder receives the target position (x,y) for
the units to go, it creates a new topographic map.

This map starts from the taget position, and
checks all neighboring squares (up to 8).
Each passable square receives a value of how many steps
where taken to reach it (the first ones get a 1 naturally,
the one in the next iteration a 2)

Each square is marked, and put on a working list.

Now for each square on the list, check its neighboring passable
squares.
If the field was not visited before, or has a higher! stepcount,
overwrite it, and give it a stepcount of my-stepcount+1,
and put it on the following workinglist.

---

As long as there is a non-empty workinglist continue.

When no more squares get added, the algorythm is finished.
it should result in a topographic map, that fills the
whole playfield with a kind of "roll down" topography
at its passable squares.

Now, every unit on a passable square can easily determine
the next best square to got to, to get closer to the taget.

(just choose the suare with the lower stepcount from
the current square.
Its like letting a marble roll down-hill towards
the goal.)

-----

This way you can let hundrets of units find the path to
the target, doing just one pathfinding run.

And: even if they block each other, you can
let them find the way without a need to rerun the
flood-fill run.
(they raise the value of previously visited suares,
making them "higher")