Sendo (os algortimos recursivos) normalmente mais simples de se entender que algoritmos iterativos. Isso não significa que são melhores, pois na maioria das vezes eles são piores que algoritmos iterativos, mas em alguns casos eles tem as suas vantagens

Vamos expandir esse tema, focando na travessia de árvores, especialmente em árvores balanceados, utilizando a biblioteca GNU libavl como referência. Vamos contrastar a 'simplicidade' da recursividade com a complexidade da itereação.

1. O que é Travessia de Árvore e por que usar Recursividade?
   Travessia de árvore é o processo de visitar todos os nós de uma árvore de maneira sistemática. Isso é frequentemente feito recursivamente. A recursividade é intuitiva aqui, pois cada subárvore de uma árvore binária, é também uma árvore binária.

2. A Simplicidade da Recursividade em Travessia
   Usando a recursividade, a travessia pode ser realizada com uma clareza impressionante. Por exemplo, em uma traversão in-order, visitamos primeiro a subárvore esquerda, depois o nó atual, e finalmente a subárvore direita. Cada um desses passos pode ser naturalmente 'convertidos' para uma chamada recursiva.

static void 
traverse_recursive (struct bst_node *node, bst_item_func *action, void *param) 
{
  if (node != NULL) 
    {
      traverse_recursive (node->bst_link[0], action, param);
      action (node->bst_data, param);
      traverse_recursive (node->bst_link[1], action, param);
    }
}

3. Desafios da Implementação Iterativa
   Por outro lado, replicar este processo de maneira iterativa exige uma abordagem mais sofisticada. Sem a pilha de chamadas natural da recursividade, precisamos gerenciar manualmente uma pilha para rastrear os nós a serem visitados. Além disso, o controle de estado para cada nó visitado torna-se um desafio.

static void 
traverse_iterative (struct bst_node *node, bst_item_func *action, void *param) 
{
  struct bst_node *stack[BST_MAX_HEIGHT];
  size_t height = 0;

  for (;;) 
    {
      while (node != NULL) 
        {
          if (height >= BST_MAX_HEIGHT) 
            {
              fprintf (stderr, "tree too deep\n");
              exit (EXIT_FAILURE);
            }
          stack[height++] = node;
          node = node->bst_link[0];
        }

      if (height == 0)
        break;

      node = stack[--height];
      action (node->bst_data, param);
      node = node->bst_link[1];
    }
}

4. Por que Considerar Iteração em Vez de Recursão?
   Embora a recursão seja mais direta, a implementação iterativa pode ser preferida em ambientes de produção, especialmente em rucurssões que podem ser longas e que poderiam causar um stackoverflow. Além disso, a recursão implica na cópia dos parâmetros para cada chamada da função o que adiciona custo computacional extra.