Post History

Yes, it's possible.

In a more general way, every recursive algorithm can be converted to an iterative one (and vice-versa).

You just need to use a [stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type)). Internally, a recursive function will use a stack to "remember" its "level" (because each recursive call is like entering a new "level" - just like dream levels in [Inception](https://en.wikipedia.org/wiki/Inception)).

To use an iterative algorithm, you must use the stack yourself. In JavaScript, we can use a simple array for that:

```javascript
function replaceIn(e) {
    // stack (actually an array) starts with element "e" in it
    var stack = [ e ];

    while (stack.length > 0) {
        // get stack's top
        var currentElement = stack.pop();
        if (currentElement.nodeType == Node.TEXT_NODE) {
            currentElement.nodeValue = currentElement.nodeValue.replaceAll("a", "");
        }
        // add all child nodes to the stack
        for (const child of currentElement.childNodes) {
            stack.push(child);
        }
    }
}
```

Let's say you call `replaceIn(document.body)`. The stack starts with `document.body` in it. Then I check if it's a text node and call `replace`.

After that, I add all child nodes of `document.body` to the stack. In the next iteration, the stack's top will be one of those nodes. Then I check if it's a text node, `replace` and add its child nodes to the stack. And so on.

The result will be the same: in the end, all the child nodes, and the grandchild nodes, and grand-grandchild nodes, etc, will be added to the stack. When there are no more child nodes to be added, the loop will finish processing all of them (and remove them from the stack, because that's what `pop` does), until the stack is empty.

---

> As a side note, for this particular case, I find the recursive algorithm more intuitive, because it's dealing with a hierarchical tree-like structure, which is recursive by definition.