7.1.

Objetivo
Aplicar los conocimientos adquiridos en los temas anteriores al realizar la
conversión de algoritmos recursivos en iterativos usando pilas como listas
lineales con simple enlace; diseñar y desarrollar programas en lenguaje C++para
implementar una versión iterativa de las Torres de Hanoi.

7.2. Introducción
Todo algoritmo recursivo puede ser transformado en otro de tipo iterativo, pero
para ello a veces se necesita utilizar pilas donde almacenar los cálculos parciales
y el estado actual del subprograma recursivo. Es posible estandarizar los pasos
necesarios para convertir un algoritmo recursivo en iterativo, aunque el algoritmo
así obtenido requerirá una posterior labor de optimización.

7.3. Conversión de algoritmos recursivos en iterativos

Para convertir un algoritmo recursivo en iterativo, puede adoptarse el esquema
siguiente:

Procedimiento Iterativo(Parametros)

Inicia Iterativo

Declaracion de variables locales;

Elemento Reg;

Repetir

Si (PrimeraLlamada) Entonces

Bloque para inicializar miembros de Reg con valores y parámetros;

Caso_Contrario

Inicia SiguientesLlamadas

Retira(Reg);

Bloque instrucciones que van después de la llamada recursiva;

Mientras (Condicion que reemplaza a la de la llamada recursiva) Hacer

Inicia InsertarPila

Bloque de instrucciones previas a la llamada recursiva;

Empuja(Reg);
 Bloque de instrucciones modifican las variables de la pila;

Fin Proceso InsertarPila

Fin Proceso SiguientesLlamadas

Mientras (Primero);

Fin Procedimiento Iterativo;

Existen algoritmos recursivos que no necesitan usar pilas para convertirlos en

iterativos, basta con usar ciclos, como lo indican los siguientes esquemas:

Procedimiento Recursivo(Parametros)

Inicia Recursivo

Declaracion de variables locales;

Si CondicionFilalizar Entonces

Bloque de finalización;

Caso_Contrario

Inicia LlamadaRecursiva

Bloque sentencias;

Recursivo(Argumentos modificados);

Fin Proceso LlamadaRecursiva

Fin Procedimiento Recursivo;

La modificación de los argumentos debe garantizar la finalización de la

recursividad. Su equivalente iterativo sería:

Procedimiento Iterativo(Parametros)

Inicia Iterativo

Declaracion de variables locales;

Si CondicionFilalizar Entonces

Bloque de finalización;
 Caso_Contrario

Mientras NO CondicionFilalizar Hacer

Inicia Equivalente

Bloque sentencias;

Sentencia modifica CondicionFilalizar;

Fin Proceso Equivalente

Fin Procedimiento Iterativo;

Como ejemplo se puede describir las versiones recursiva e iterativa de la función

de Fibonacci:

Funcion FibonacciR(X: Entero): Entero

Inicia FibonacciR

Si X < 2 Entonces

Retornar X;

Caso_Contrario

Retornar FibonacciR(X – 1) + FibonacciR(X – 2);

Fin Funcion FibonacciR;

Funcion FibonacciI(X: Entero): Entero

Inicia FibonacciI

Var

Siguiente, Este = 1, Anterior = 0, I: Entero;

Si X < 2 Entonces

Retornar X;

Caso_Contrario

Inicia Equivalente
 Para I = 2 : X Hacer

Inicia Repetitivo

Siguiente = Este + Anterior;

Anterior = Este;

Este = Siguiente;

Fin Proceso Repetitivo

Retornar Siguiente;

Fin Proceso Equivalente;

Fin Funcion FibonacciI;

Ejercicio de aplicación
Efectuar el análisis, diseño, implementación en C++ que utilice las librerías
pertinentes para realizar la conversión a una versión iterativa del problema de
las 8 reinas.

Recursos complementarios
Sugerencias para que pueda ampliar la información sobre el tema trabajado,
como parte de un proceso de aprendizaje autónomo

* Textos sobre estructura de datos

http://www.calcifer.org/documentos/librognome/glib-lists-queues.html

http://virtual.umng.edu.co/distancia/ecosistema/odin/odin_desktop.php?path=Li
4vb3Zhcy9pbmdlbmllcmlhX2luZm9ybWF0aWNhL2VzdHJ1Y3R1cmFfZGVfZGF
0b3MvdW5pZGFkXzMv

* Texto sobre estructuras lineales

http://www.colimbo.net/documentos/documentacion/113/FPII03_Estructuras_lin
eales_de_datos.pdf

* Video sobre estructuras lineales

https://www.youtube.com/watch?v=-Shr2s0gYao

* Texto sobre pilas lineales

https://accedacris.ulpgc.es/bitstream/10553/1542/1/580.pdf

Bibliografía
Meneses Becerra, F. Estructuras de datos en C++.

Wirth, N. Algoritmos + Estructuras de datos = Programas.

Autoevaluación
1. Todo algoritmo iterativo puede ser transformado en otro de tipo recursivo

Verdadero

Falso

2. Seleccione la opción correcta según el siguiente enunciado:

Todo algoritmo recursivo puede ser transformado en otro de tipo iterativo, pero
para ello a veces se necesita utilizar:

Pila donde almacenar

Algoritmo de recursión directa

Uso de sentencias repetitivas

Uso de grafos

3. Dado el siguiente esquema para tranformar algoritmo recursivo en iterativo,

puede adoptarse, elija la opción que complete las líneas que le faltan.:

Procedimiento Iterativo(Parametros)

Inicia Iterativo

Declaracion de variables locales;

Elemento Reg;

//línea 1
 Si (PrimeraLlamada) Entonces

Bloque para inicializar miembros de Reg con valores y parámetros;

//línea 2

Inicia SiguientesLlamadas

Retira(Reg);

Bloque instrucciones que van después de la llamada recursiva;

Mientras (Condicion que reemplaza a la de la llamada recursiva) Hacer

//línea 3

Bloque de instrucciones previas a la llamada recursiva;

Empuja(Reg);

Bloque de instrucciones modifican las variables de la pila;

Fin Proceso InsertarPila

Fin Proceso SiguientesLlamadas

Mientras (Primero);

Fin Procedimiento Iterativo;

Línea 1

Repetir

Línea 2

Caso_Contrario

Linea 3

Inicia InsertarPila

Línea 1

Hacer_Mientras

Línea 2

Si(pila_valida)entonces
Linea 3

Reg->0

Línea 1

Repetir

Línea 2

Si(pila_valida)entonces

Linea 3

Inicia InsertarPila

Línea 1

Repetir

Línea 2

Mientras (condición Exista valores) hacer

Linea 3

Inicia InsertarPila
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

7.4. Versión iterativa de las Torres de Hanoi

A continuación se presenta la versión iterativa de las Torres de Hanoi usando pilas.

Programa en C++

Diagrama del Proyecto:                                                                          En la cabecera

de CListaSE.h

Configuración de directorios de búsqueda para compilación

// ItemHano.h

#ifndef ITEMHANOI_H

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 1/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

#define ITEMHANOI_H

#include <iostream>

#include <stdio.h>

#include<cstdlib>

#include <string.h>

#include <ERROR.HPP>

using namespace std;

class Elemento

    public:

        int Alt, Org, Dst, Aux;

        Elemento() {}

        virtual ~Elemento() {}

        Elemento GetDato() {return GetEste(); }

                void SetDato(Elemento X) {Copiar(X); }

                Elemento GetEste() {return *this; }

                void Copiar(Elemento X) {*this = X;}

                int Leer(int) {}

                void Mostrar() {}

                int Compara(Elemento) {}

    protected:

    private:

};

#endif // ITEMHANOI_H

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 2/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

// CHanoi.h

#ifndef CHANOI_H

#define CHANOI_H

#include <CLstSEInsel.h>

class CHanoi : public CLstSEInsel

    public:

        CHanoi();

        virtual ~CHanoi();

        void MoverDiscosI(int, int, int, int);

        void PasarDisco(int, int, int);

        void EscribirPoste(int);

        void Intercambia(int &a, int &b)

          {

              int aux = a;

              a = b;

              b = aux;

          }

    protected:

    private:

};

#endif // CHANOI_H

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 3/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

// CHanoi.cpp

#include "CHanoi.h"

/* DESCRIPCION DE LAS FUNCIONES PARA LAS TORRES DE HANOI

     VERSION ITERATIVA USANDO PILAS */

CHanoi::CHanoi()

    //ctor

CHanoi::~CHanoi()

    //dtor

void CHanoi::PasarDisco(int n, int org, int dst) {

   cout << "Pasar el disco " << n << " desde el poste ";

   EscribirPoste(org);

   cout << " hacia el poste ";

   EscribirPoste(dst);

   cout << endl;

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 4/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

void CHanoi::EscribirPoste(int p) {

    switch (p) {

       case 0: cout << "izquierdo"; break;

       case 1: cout << "medio"; break;

       case 2: cout << "derecho"; break;

    }

void CHanoi::MoverDiscosI(int Altura, int Origen,

                          int Destino, int Auxiliar)

 { // MoverDiscosI

    Elemento Reg;

    int PrimLlam = 1;

    do {

      if (PrimLlam) {

        Reg.Alt = Altura;

        Reg.Org = Origen;

        Reg.Dst = Destino;

        Reg.Aux = Auxiliar;

        PrimLlam = 0;

      }

      else {

        Retira(Reg);

        PasarDisco(Reg.Alt,Reg.Org,Reg.Dst);

        Reg.Alt--;

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 5/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

        Intercambia(Reg.Org, Reg.Aux);

      }

      while (Reg.Alt > 1) {

        Empuja(Reg);

        Reg.Alt--;

        Intercambia(Reg.Dst, Reg.Aux);

      }

      PasarDisco(Reg.Alt,Reg.Org,Reg.Dst);

    }

    while (Primero);

 } // MoverDiscosI

// TorHanoiIterativo

#include "CHanoi.h"

int main()

    int n, origen, destino;

    CHanoi CH;

    while (1) {

        cout << "Ingresar el numero de discos (salir < 1 o > 10): ";

        cin >> n;

        if (n < 1 || n > 10) break;

        cout << "Ingresar el poste origen:\n";

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 6/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

        cout << "0 --> Izquierdo, 1 --> Medio, 2 --> derecho (salir --> otro valor): ";

        cin >> origen;

        if (origen < 0 || origen > 2) break;

        cout << "Ingresar el poste destino:\n";

        cout << "0 --> Izquierdo, 1 --> Medio, 2 --> derecho (salir --> otro valor): ";

        cin >> destino;

        if (destino < 0 || destino > 2 || origen == destino) break;

        cout << "Secuencia de pasos para mover " << n << " discos desde el poste ";

        CH.EscribirPoste(origen);

        cout <<" hacia el poste ";

        CH.EscribirPoste(destino);

        cout << endl;

        CH.MoverDiscosI(n, origen, destino, 3 - origen - destino);

        cout << endl;

    }

    return 0;

Resultados de la corrida:

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 7/8
21/11/22, 21:07 7.4. Versión iterativa de las Torres de Hanoi | Tema 7: Pilas como listas lineales con simple enlace

Obra publicada con Licencia Creative Commons Reconocimiento No comercial Compartir

igual 4.0

Unidad de Educación a Distancia

https://evirtual.espe.edu.ec/programas_scorm.cgi?id_curso=22923&id_unidad=259709&id_pkg=105477&wAccion=ver_scos#ver_documento 8/8