Instituto Politécnico Nacional

Unidad Profesional Interdisciplinaria de Ingeniería y

Ciencias Sociales y Administrativas

Algoritmos Computacionales

3CM4

Trabajo 3° Parcial
͞Actividades del Polilibro͟

Fecha de Entrega
1-Diciembre-2010

1
 Elaborado por:

Unidad I

@‘ Canseco Camacho José Javier

@‘ èuzmán Enríquez Víctor Hugo
@‘ èarcía èutiérrez Marco Esteban
@‘ Méndez Durán Alejandro

Unidad II

@‘ Camacho Santana Karen Crisol

@‘ Díaz Flores Mauricio Alexandri
@‘ Santiago Jiménez Ana Cristina
@‘ Sastré èarcía Laura Elena

Unidad III

@‘ ·lancarte èonzález Alicia

@‘ Morales Reyes Aleida Esmeralda
@‘ årozco Reyes Anayeli
@‘ Paredes Carrillo Nataly

Unidad IV

@‘ Hernández åjeda Miguel Ángel

@‘ Trejo Sánchez Jessica Daniela
@‘ Juárez Hotlzhaimer Hans

Unidad V

@‘ Alcaráz Téllez José Alberto

@‘ Calvo Castillo Norberto
@‘ Espinosa èonzález Aldo Iván
@‘ Estrada Pacheco Rubén
@‘ Huitrón Velázquez José Antonio
@‘ Juárez èonzález Juan Carlos
@‘ Pérez Solís Héctor Ulises
@‘ Ruiz Miranda Abigail

2
3
 A

Unidad I ......................................................................................................................................... 5
Unidad II ........................................................................................................................................ 7
Unidad III ..................................................................................................................................... 12
Unidad IV ..................................................................................................................................... 25
Unidad V ...................................................................................................................................... 30
Conclusiones͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙56

·ibiografía͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙͙

4
a

Compara objetivos, alcance y contenidos de asignaturas similares en al menos 2 planes de
estudios de otras instituciones (por ejemplo a las que asisten vecinos o familiares tuyos,
que se presentan en Internet) y responde las siguientes preguntas. Envía tus respuestas
por correo.

¿Cuáles son las principales diferencias en los aspectos que continuación se enuncian?

@‘ Temas incluidos.

>> RESPUESTA >>

Hay una gran diferencia entre los planes de estudios de las distintas escuelas
revisadas. Todas las escuelas enseñan lo básico de los algoritmos: conceptos básicos,
datos, pseudocódigo, diagrama de flujos, lenguaje maquina, etc. Lo que diferencia con
UPIICSA es que nosotros vemos también el Manejo de Datos: Métodos de · squeda y de
årdenamiento

@‘ åbjetivo general.

>> RESPUESTA >>

Todas buscan que el alumno obtenga conocimientos para poder crear un algoritmo
que le permita la solución de problemas, la documentación de la creación del algoritmo y
la implementación del algoritmo. La diferencia entre los planes de estudio es la rama hacia
donde se van a dirigir estos conocimientos: la automatización de maquinaria o la
programación de software

@‘ åbjetivos por temas.

>> RESPUESTA >>

Las diferencias entre los objetivos por temas son por el orden en que se ensañan
los temas, puesto que cada escuela tiene formas distintas de agrupar los temas

@‘ ·ibliografía base de consulta y de apoyo.

>> RESPUESTA >>

Solo una escuela investigada utiliza información que se encuentra en la red. Esta
información son investigaciones realizadas o que son realizadas por otras escuelas en el
mundo; de tal manera están actualizados con las nuevas metodologías. El resto de las
escuelas se basan en libros que son de sus propios profesores, encerrándose con la misma
información.

5
 @‘ Respecto a tus expectativas al cursar la asignatura, ¿qué ideas te sugieren
los otros planes de estudio para una mayor coincidencia con el objetivo, la
ubicación y los alcances de esta asignatura?

>> RESPUESTA >>

Una buena idea que se podría agregar sería la programación práctica de los
algoritmos o de código de programación en el laboratorio de cómputo, dentro del horario
de clases; debido a que algunas dudas solo se muestran al momento de programar en la
computadora y si solo se programa en casa pues la duda no será resuelta.

åtra buena idea es basarse en los conocimientos que se están dando a conocer de otras
escuelas, no siempre ocupar los mismos libros que con el tiempo se van quedando en el
olvido puesto que jamás se actualizaron.

6
a

Desarrolle el algoritmo, utilizando pseudocódigo, para:

@‘ Ir al cine.

>> RESPUESTA >>

ir al cine
void elegir pelicula()
get (cartelera)
void cartelera(cartelera)
get (pelicula)
void pelicula(pelicula)
if(pelicula = deseada)
{
get(horario)
}
else
{
"elegir otra opcion"
void horario(horario)
if(horario = desado)
{
comprar boletos()
get(cantidad)
}
else
{
"elegir otra opcion"
}
comprar boletos(cantidad)
if(cantidad >= precio boletos)
{
"disfruta la pelicula"
}
else
{
"elige otra opcion"
}
comprar dulces (dinero)
if (dinero >= dulces)
{
"comprar dulces"
}
else

7
 "no comprar nada"
}

while (pelicula = = continue)

{
"seguir en el cine"
}
"salir del cine"
FIN

@‘ Enviar un e-mail.

>> RESPUESTA >>

Dar click en nuevo
èet (correo)
Para = correo;
èet (asunto)
Asunto = asunto;
èet (texto)
Contenido = texto;
if(para != null) {
͞mandar correo͟
}
Else {
͞Poner una dirección de correo electrónico͟
}
Click en enviar
FIN

@‘ Solicitar en préstamo implementos deportivos.

>> RESPUESTA >>

inicio();
ve a gym;
si(gym=cerrado)
hasta que (gym=abierto;){
regresa despues
}
si(gym=abierto)
piede ("articulo");
entrega (&"credencial);
fin();

$
 @‘ Acceder a una página web.

>> RESPUESTA >>

inicio();
encender computadora;
ingresa al explorador;
ingresa(&"direccion");
lee contenido;
si(pagina=incorrecta);
hasta que(pagina=correcta;){
busca pagina}
si es correcta;
fin();

@‘ Enviar un e-mail a todos los alumnos del curso.

>> RESPUESTA >>

Dar click en nuevo
èet (correo)
Para = correo;
èet (asunto)
Asunto = asunto;
èet (texto)
Contenido = texto;
if(para != null) {
͞mandar correo͟
}
Else {
͞Poner una dirección de correo electrónico͟
}
If(quieres otro correo?)
{
Return poner una dirección
}
Else {
Click en enviar
}
FIN

€
 @‘ Enviar un e-mail al profesor.

>> RESPUESTA >>

Dar click en nuevo
èet (correo)
Para = correo;
èet (asunto)
Asunto = asunto;
èet (texto)
Contenido = texto;
if(para != null) {
͞mandar correo͟
}
Else {
͞Poner dirección de correo electrónico maestro͟
}
If(quieres otro correo?)
{
Return poner una dirección
}
Else {
Click en enviar
}
FIN

@‘ Sumar dos n meros.

>> RESPUESTA >>

variables
entero a, b, suma

inicio
escribir( "Introduzca primer n mero (entero): " )
leer( a )
escribir( "Introduzca segundo n mero (entero): " )
leer( b )

suma і a + b

si ( suma > 0 )
escribir( "LA SUMA SÍ ES MAYåR QUE CERå." )
sino
escribir( "LA SUMA Nå ES MAYåR QUE CERå." )
fin_si.

10
 @‘ Sumar los primeros cien n meros naturales.

>> RESPUESTA >>

Funcion Sumatoria
Inicio
suma=0
Para i desde 1 hasta 100
suma=suma+i
i=i+1
Fpara
Escribir suma
Fin

@‘ årdenar tres n meros.

>> RESPUESTA >>

Dimension numero[3];
Para indice<-1 Hasta 3 Hacer
Escribir 'Ingrese el elemento numero ',indice,' : ';
Leer numero[indice];
FinPara
Para indice<-1 Hasta 2 Hacer
para subindice<-2 Hasta 3 Hacer
si (numero[indice]<numero[subindice]) Entonces
aux<-numero[indice];
numero[indice]<-numero[subindice];
numero[subindice]<-aux;
FinSi
FinPara
FinPara
Escribir '------årdenados-------'
Para indice<-1 Hasta 3 Hacer
Escribir 'Elemento numero ',indice,' : ',numero[indice];
FinPara
FinProceso

11
a

Ejercicios de estructuras dinámicas.

Ejercicio 1

Dada la siguiente declaración de tipo lista circular ordenada.

TYPE
Tlista:^Elemento;
Elemento=RECåRD
Clave:INTEèER;
Info:Tinfo;
Sig:Tlista
END;

Codificar un algoritmo que realice la inserción de un elemento, representando por

una clave y una información, en una lista circular como la anteriormente descrita.

>> RESPUESTA >>

Para eliminar el caso de insertar antes del primer elemento vamos a utilizar una lista con
cabecera ficticia. Todo queda reducido a insertar en cualquier lugar o si la lista está vacía.

PRåCEDURE Introducir (VAR Lista:Tlista;Eclave:INTEèER;Einfo:Tinfo);

VAR Nuevo,Ant,Act:Tlista;
(* Para poder insertar antes necesitamos dos punteros *)
·EèIN
IF lista=NIL
(* Regresa resultado *)
THEN ·EèIN
(* Creamos la cabecera ficticia *)
NEW(Lista);
NEW(Lista^.Sig);
Lista^.Sig^.Clave:=Eclave;
Lista^.Sig^.Info:=Einfo;
Lista^.Sig^.Sig:=Lista
END
(*Retornamos al inicio*)
ELSE ·EèIN
Ant:=Lista;
(* Al primer elemento de la lista *)
Act:=Lista^.Sig;
(* Mientras no apunte al ltimo elemento *)
INTEèER act<>lista
and Act^.Clave<Eclave do

12
·EèIN
Ant:=Act;
Act:=Act^.Sig
END;
NEW(Nuevo);
Nuevo^.Info:=Einfo;
Nuevo^.Clave:=Eclave;
Nuevo^.Sig:=Act;
Anterior^.Sig:=Act;
Anterior^.Sig:=Nuevo
END
END;

Ejercicio 2

Dada la siguiente declaración de lista:

TYPE
Tlista:^Artículo;
Articulo=RECåRD
Codigo,Cont_Pedida:INTEèER;
Sig:Tlista
END;

Se tiene una lista en la que se han introducido pedidos seg n el orden de llegada,
por lo que puede haber pedidos del mismo artículo. Se pide, codificar un procedimiento
que, dada una lista como la anteriormente descrita, devuelva un nico elemento por cada
artículo, en el cual el campo Cant_Pedida tenga la suma de todas las cantidades pedidas
de ese artículo.

>> RESPUESTA >>

No se pueden utilizar estructuras auxiliares, así como tampoco estructuradas de control
como INTEèER, for o REPEAT.
(*Procediminentos*)
PRåCEDURE Eli_Codigo(VAR Lista:Tlista);
PRåCEDURE Elimina(VAR L:Tlista;Cod:INTEèER;VAR Suma:INTEèER);
VAR Aux:Tlista;

·EèIN
(*Se realize la decision entre los ciclos*)
IF L<>NIL
(*Retorna la información y la guarda en Cod*)
THEN IF L^.Codigo=Cod

13
(*Aqui es donde regresa el resultado al inicio*)
THEN ·EèIN
Aux:=L;
(*Cantidad pedida es igual a cantidad total*)
Suma:=Suma+L^.Cant_Pedida;
L:=L^.Sig;
(*Se inserta el auxiliar*)
DISPåSE(Aux);
Elimina(L,Cod,Suma)
(*Realiza la function A(m,n)Ackerman*)
END
ELSE Elimina(L^.Sig,Cod,Suma)
END;
·EèIN
IF Lista<>NIL
(*Aqui es donde regresa el resultado al inicio*)
THEN ·EèIN
Elimina(Lista^.Sig,Lista^.Codigo,Lista^.Cant_Pedida);
Eli_Codigo(Lista^.Sig)
END
END;

Ejercicio 3

Utilizando el TAD pila pasar de la notación normal a la notación polaca inversa.

Ejemplos: (A·+), (A·+C*).El símbolo '#' va a ser el principio y el final de la formula.

1. Símbolo que llega introducimos en la pila.

2. El primer elemento en la pila se saca y se intenta introducir el signo que entra.
3. Si se dan dos paréntesis complementarios se eliminan los dos.
4. Llega el final de la formula (#).

Entradas
+-------------------------+
C | |# + Ù * / ( )|
o +---+---------------------|
n |#|4 1 1 1 1 1 E|
t |+|2 2 2 1 1 1 2|
e |Ù|2 2 2 1 1 1 2|
n |*|2 2 2 2 2 1 2|
i |/|2 2 2 2 2 1 2|
d |(|E 1 1 1 1 1 3|
o +--------------------------+

14
>> RESPUESTA >>
+-------------------------+
C | |# + - * / ( )|
+---+---------------------|C
n | # | 1 1 1 1 1 E C|
t | + | 2 2 1 1 1 2 +| | se elimina
e | - | 2 2 1 1 1 2- ||
n | * | 2 2 2 2 1 2 *|
| / | 2 2 2 2 2 1 2+ /|
| ( | E 1 1 1 1 1 3 (|#
o +-------------------------+
Ejercicio 4

Utilizando el TAD pila pasar de la notación normal a la notación polaca inversa.

Ejemplos: (A·+), (A·+C*).El símbolo '#' va a ser el principio y el final de la formula.

1. Símbolo que llega introducimos en la pila.

2. El primer elemento en la pila se saca y se intenta introducir el signo que entra.
3. Si se dan dos paréntesis complementarios se eliminan los dos.
4. Llega el final de la formula (#).

Entradas

+-------------------------+
C | |# + Ù * / ( )|
o +---+---------------------|
n |#|4 1 1 1 1 1 E|
t |+|2 2 2 1 1 1 2|
e |Ù|2 2 2 1 1 1 2|
n |*|2 2 2 2 2 1 2|
i |/|2 2 2 2 2 1 2|
d |(|E 1 1 1 1 1 3|
o +-------------------------+

>> RESPUESTA >> +-------------------------+

C | |# + - * / ( )|
C +---+---------------------|
||#|4 1 1 1 1 1 E|
||+|2 2 2 1 1 1 2|
|-|2 2 2 1 1 1 2|
n |*|2 2 2 2 2 1 2|
i |/|2 2 2 2 2 1 2|
d |(|E 1 1 1 1 1 3|
o +-------------------------+

15
Ejercicios de recursividad

Ejercicio 1

Realizar un seguimiento de estos subprogramas recursivos.

a) PRåCEDURE p1 (a:INTEèER);
·EèIN
IF a>0
THEN ·EèIN
WRITELN;
p1(a-1)
END
ELSE WRITELN('FIN')
END;
Salida: a, a-1, a-2, ..., 1, FIN

>> RESPUESTA >>

Ejercicio 2

Escribir una función recursiva que calcule la suma de todos los elementos
contenidos en un ARRAY de enteros. No se puede utilizar ning n bucle.

FUNCTIåN Suma (VAR a:Ttabla, n:INTEèER):INTEèER;

·EèIN
IF n>0
THEN Suma:=a[n]+Suma(a,nÙ1)
ELSE Suma:=0
END;

>> RESPUESTA >>

Ejercicio 3

Escribir una función que diga si una palabra es o no capic a (la palabra esta en una
tabla)

FUNCTIåN Capicua (Palabra:Tpalabra;Ini,Fin:INTEèER):·ååLEAN;

·EèIN
IF Ini>=Fin
THEN Capicua:=TRUE
ELSE Capicua:=(Palabra[Ini]=Palabra[Fin]) AND (Capicua(Ini+1,FinÙ1)
END;

16
>> RESPUESTA >>
FUNCTIåN Capicua (Palabra:Tpalabra;Ini,Fin:INTEèER):·ååLEAN;
·EèIN
Long palabra=smms;
Long falta, palabrainvertida,resto;
IF Ini>=Fin
char array[25], array2[25];
clrscr();
printf("Ingrese el numero de letras:");
scanf("%i",&x);
printf("\n");
for(n=1;n<=x;n++)
if(array[n]==array2[n])
{
acum=acum+1;
}
THEN Capicua:=TRUE
ELSE Capicua:=(Palabra[Ini]=Palabra[Fin]) AND (Capicua(Ini+1,Fin 1)
END;

Ejercicio 4

Hacer un seguimiento y obtener el resultado para Incognita ($).

FUNCTIåN Incognita (Num:INTEèER):INTEèER;

·EèIN
IF (Num>0) AND (Num<11)
THEN Incognita:=Incognita(NumÙ1)+Incognita(Num+4)
ELSE IF Num<=0
THEN Incognita:=0
ELSE Incognita:=1
END;

+------------------------------------------------+
| |
THEN ELSE |
I($) ------> I(12) ------> I=1 |
| |
| THEN THEN +----+ |
+----> I(6) -------> I(10) -------> |I($)+--+
| | +----+
| |
+-----> I(4) +------> I(4)
Se produce un bucle infinito, el programa no acaba nunca.

17
>> RESPUESTA >>
·EèIN
IF (2>0) AND (2<11)
THEN Incognita:=$(2Ù1)+$(2+4)
ELSE IF Num<=0
THEN Incognita:=0
ELSE Incognita:=1
END;

+------------------------------------------------+
| |
THEN ELSE |
I(2) ------> I(12) ------> I=$ |
| |
| THEN THEN +----+ |
+----> $(1) -------> $(6) -------> |I(2)+--+
| | +----+
| |
+-----> I(-1) +------> (56)
El resultado de la incognita($) es 56.

Ejercicio 5

Realizar un seguimiento de la siguiente función, para los parámetros:

a) x:=Concurso (0,3)
b) y:=Concurso(10,Ù7)
c) z:=Concurso(5,5)

FUNCTIåN Concurso (·ase,Lim:INTEèER):INTEèER;

·EèIN
IF ·ase=Lim
THEN Concurso:=1
ELSE IF ·ase>Lim
THEN Concurso:=0
ELSE Concurso:=·ase+Concurso(·ase+1,Lim)
END;

La salida es: x=4, y=0 y z=1

·=0,L=3 ----> Con=0+Con(1,3)=4 ; ·=1,L=3 ----> Con(2,3)=3
·=2,L=3 ----> Con=2+Con(3,3)=1 ; ·=3,L=3 ----> Con=1

1$
>> RESPUESTA >>
X no entra dentro de los parámetros establecidos anteriormente, sin embargo, y si ya que
es cero y lo establecido dice que debe estar entre (10, -7), y z tampoco ya que es de 5 5
ambos positivos y anteriormente nos dice que vale 1 no está en el dentro del rango

Ejercicio 6

Simular el bucle FåR mediante procesos recursivos.

PRåCEDURE ·ucle (Inf,Sup:INTEèER);
·EèIN
IF Inf<=Sup
THEN ·EèIN
Proceso(...);
·ucle(Inf+1,Sup)
END
END;

>> RESPUESTA >>

PRåCEDURE ·ucle (Inf,Sup:4);
PRåCEDURE ·ucle (Inf,Sup:4);
·EèIN
IF Inf<=Sup
THEN ·EèIN
/* Proceso (...V
 
 
   



/*simulación del bucle for
La sentecia realiza una repetición desde la inicialización hasta el término del bucle. Para
llevar la cuenta se utiliza una variable, ya veremos en el ejemplo cómo se utiliza esta
variable. Con cada ejecución del bucle se ejecutan unas sentencias. NEXT sirve para
delimitar el final del bucle, cuando se encuentra con el NEXT se vuelve otra vez al principio
del FåR, así hasta realizar el n mero de ejecuciones determinado.
Existe un valor que sirve para indicar lo grandes que se desean realizar los saltos entre
ejecución y ejecución, es el valor STEP. Un STEP 2 determinaría que entre ejecución y
ejecución la variable se ha de incremetar en 2 unidades. En el caso de no indicar nada se
realizan pasos de 1 en 1. También podemos realizar pasos en valores negativos.*/
for i=0 to 6 step 2
msgbox(i)
next
);
·ucle for (Inf+1,Sup)
END
}
END;

1€
Ejercicio 7

Implementar una función recursiva que dados dos n meros, dé como resultado la
multiplicación del primero por el segundo. Solo se puede utilizar la función SUCC de pascal
(entero) y no se pueden usar bucles.
a*b = a+a+a+...+a b veces.
a+b = a+1,+1,+1,... ----> Hacer b veces SUCC de a.
FUNCTIåN Suma (a,b:INTEèER):INTEèER;
·EèIN
IF b>m
THEN Suma:=Suma(SUCC(a),b,SUCC(m))
ELSE Suma:=a
END;

FUNCTIåN Producto (c,d,m:INTEèER):INTEèER;

·EèIN
IF c=0 åR d=0
THEN Producto:=0
ELSE IF d>m
THEN Producto:=Suma (Producto(c,d,SUCC(m)),c,0)
ELSE Producto:=0
END;
>> RESPUESTA >>
La función "succ" lo que hace es asignar a "x" variable el sucesor del n mero que ésta
almacene, es decir, si x = 1, su sucesor es el 2, entonces al hacer esto "x = succ(x)", x
sustituye el 1 por el 2.
Código:
Program Multiplicacion;
uses crt;
var
i, n1, n2, multiplicacion : integer;
begin
clrscr;
writeln('Introduce el 1°n mero');
readln (n1);
writeln('Introduce el 2° n mero);
readln(n2);
multiplicacion:=0;
for i:=1 to n1 do
multiplicacion := succ(multiplicacion);
for i:=1 to n2 do
multiplicacion := multiplicacion(multiplicacion);
writeln('La multiplicación de ',n1,' * ',n2,' es: ',multiplicacion);
readln; end;

20
Ejercicio 8

Dado el siguiente procedimiento recursivo:

a) Calcular el numero de llamadas que se harán al procedimiento recursivo en función de

n.
b) Si en el punto * p * la pila interna del sistema tiene capacidad para almacenar un
máximo de 32405 bytes y suponiendo que:
· La dirección de retorno de un procedimiento ocupa 4 bytes.
· Una variable entera ocupa 2 bytes.

Calcular el valor máximo de n para el que se pueda ejecutar la llamada P(n) sin que se
desborde la pila.Razonar las respuestas.
PRåCEDURE p(n:INTEèER);
PRåCEDURE Recursivo (m,n:INTEèER);
VAR i:INTEèER;
·EèIN
IF m>1
THEN IF n>1
THEN Recursivo(m,nÙ1)
ELSE Recursivo (mÙ1,mÙ1);
i:=m*n;
WRITELN(i);
END;

·EèIN
IF n>=1
THEN ·EèIN (** p **)
Recursivo(n,n);
WRITELN('fin')
END
END;

Cada llamada ocupa 10 bytes de la pila, la llamada $ ,2 de cada variable y 2

también de cada variable local
a) H m=n=1 se acaba.
H m>1 n>1 realiza (m,nÙ1)
H m>1 n=1 realiza (mÙ1,mÙ1)
si se hace la llamada con n tenemos:
(n,n) +---> (n-1,n-1) +---> (n-2,n-2)
(n,n-1) | (n-1,n-2) | (n-2,n-3)
(n,n-2) | (n-1,n-2) | ...
... | ... | Hasta que los
(n,1) ---+ (n-1,1) ---+ dos sean 1

21
Ejercicio 9

Invertir una pila sin ninguna estructura auxiliar, y con las operaciones: cima, decapitar,
vacía, introducir.

PRåCEDURE Invertir (VAR p:Tpila);

VAR a:Telemento;
·EèIN
IF NåT Vacia(p)
THEN ·EèIN
Cina(p,a);
Decapitar(p);
Invertir(p);
InsertaFinal(p,a)
END
END;

PRåCEDURE InsertaFinal (VAR p:Tpila; a:Tele);

VAR Ele:Tele;
·EèIN
IF NåT Vacia(p)
THEN ·EèIN
Cima(p,Ele);
Decapitar(p);
InsertaFinal(p,a);
Introducir(p,Ele)
END
ELSE Introducir (p,a)
END;

>> RESPUESTA >>

Codigo:

void Invertir (Tpila *p)

{
Telemento a;
if !Vacia(p)
{
Cima(p,a);
Sacar(p);
Invertir(p);
InsertaFinal(p,a);
}
void InsertaFinal (Tpila *p; Telemento a)
{
22
 Telemento elem;
if !Vacia(p)
{
Cima(p,elem);
Sacar(p);
InsertaFinal(p,a);
Introducir(p,elem);
}
else Introducir (p,a);
}

Ejercicio 10

Descríbase el efecto de los siguientes procedimientos y funciones:

1) PRåCEDURE p2 (a,b:INTEèER);
·EèIN
IF a MåD b <>0
THEN ·EèIN
WRITELN(a);
p2(a+1,b)
END
END;

Suponiendo que la llamada al procedimiento p2 se hace siempre de la siguiente forma:

if a>b
THEN p2 (abs(a),abs(b));

2) PRåCEDURE p3(a,b:INTEèER);
·EèIN
IF a>0
THEN p3 (aÙ1,b+a)
ELSE WRITELN(b);
END;

>> RESPUESTA >>

Con el siguiente procedimiento se encuentra la secuencia de n meros desde `a' hasta
llegar al entero anterior a un divisor de `a + b' .
Por ejemplo si introdujéramos los n meros a=10 y b=$ los resultados que se obtendrían
de ejecutar el procedimiento serian:
10
11
12
13
14
23
15
16
17

2)
Con el siguiente procedimiento se encuentra la secuencia de n meros regresivos a partir
de a
Por ejemplo si introdujéramos los n meros a=6 los resultados que se obtendrían de
ejecutar el procedimiento serian:
6
5
4
3
2
1

24
a

1. Explique el método de ordenamiento de Quick Sort.

>> RESPUESTA >>

El método de ordenamiento Quick Sort es actualmente el más eficiente y veloz de los
métodos de ordenación interna. Es también conocido con el nombre del método rápido y
de ordenamiento por partición, en el mundo de habla hispana.
Este método es una mejora sustancial del método de intercambio directo y recibe el
nombre de Quick Sort por la velocidad con que ordena los elementos del arreglo.
La idea central de este algoritmo consiste en los siguientes:
Se toma un elemento x de una posición cualquiera del arreglo.
Se trata de ubicar a x en la posición correcta del arreglo, de tal forma que todos los
elementos que se encuentran a su izquierda sean menores o iguales a x y todos los
elementos que se encuentren a su derecha sean mayores o iguales a x.
Se repiten los pasos anteriores pero ahora para los conjuntos de datos que se encuentran
a la izquierda y a la derecha de la posición correcta de x en el arreglo.

2. Elabore una prueba para el algoritmo de Cota Inferior. Utilizando los datos de un
arreglo de $ elementos.

>> RESPUESTA >>

Uno de los métodos que usa la cota inferior como función es el método de heapshort
como el siguiente:
#include <iostream>
using namespace std;
int main()

{
int A[100],j,item,temp,i,k,n;
cout<<" [[::::METåDå DE HEAPSåRT::::]]\n\n"<<endl;
cout<<"Introduce la capacidad de la matriz"<<endl;
cin>>n;
cout<<"Introduce los "<<n<<" numeros"<<endl;
for(int i=1;i<=n;i++)
{cin>>A[i];
}
system("cls");
cout<<" [[::::METåDå DE HEAPSåRT::::]]\n\n"<<endl;
cout<<"Los datos en desorden son:\n";
for(int i=1;i<n+1;i++)
{cout<<A[i]<<"\n";
}

for(k=n;k>0;k--)

25
{
for(i=1;i<=k;i++)

{
item=A[i];
j=i/2;
while(j>0 && A[j]<item)
{

A[i]=A[j];
i=j;
j=j/2;

}A[i]=item;
}temp=A[1];
A[1]=A[k];
A[k]=temp;
}cout<<"Los datos en orden son:"<<endl;

for(i=1;i<=n;i++)
cout<<A[i]<< endl;
system("Pause");
return 0;
}

Para el arreglo datos={10,5,4,23,1,4,$,5}

26
3. Explique las variantes del algoritmo de Quick Sort.

>> RESPUESTA >>

Clases de Quicksort empleando a divídase y conquiste estrategia para dividir a lista en dos
sublistas.
Los pasos son:
1.‘ Escoja un elemento, llamado a O 
, de la lista.
2.‘ Reordene la lista de modo que todos los elementos que son menos que el pivote
vengan antes del pivote y de modo que todos los elementos mayor que el pivote
vengan después de él (los valores iguales pueden ir cualquier manera). Después de
este repartir, el pivote está en su posición final. Esto se llama partición operación.
3.‘ Recurrentemente clasifique la sublista de pocos elementos y la sublista de
mayores elementos.
4. ¿Para que se utiliza la notación asintótica?

>> RESPUESTA >>

Una notación matemática usada en algoritmia que indica el comportamiento límite de una
función. A este tipo de notación se le llama "notación asintótica

5. Elabore una prueba para el algoritmo de Máximo Secuencial para un arreglo de $

elementos.

>> RESPUESTA >>

#include <iostream>
#include <cstdlib>

using namespace std;

void muestraMax(int);
int maximo(int[],int);

27
main()
{int numeros[200],tam,i,j;
cout<<" [[::::MEAXIMå SECUENCIAL::::]]\n\n"<<endl;
cout<<"Introduce la capacidad de la matriz"<<endl;
cin>>tam;
cout<<"Introduce los "<<tam<<" numeros"<<endl;
for(int i=0;i<tam;i++)
{cin>>numeros[i];
}
system("cls");
cout<<" [[::::MAXIMå SECUENCIAL::::]]\n\n"<<endl;
cout<<"Los datos son:\n";
for(int i=0;i<tam;i++)
{cout<<numeros[i]<<"\n";
}
cout<<"\nEl maximo es:\n";
int m=maximo(numeros,tam);
muestraMax(m);

system("Pause");
return 0;
}

int maximo(int datos[],int n)

{int m=datos[0],i=1;
do{if(m<datos[i])
{m=datos[i];}
i=i+1;
}while(i<n);
return m;
}
void muestraMax(int m)
{cout<<m<<"\n";
}
PRUE·A DE ESCRITåRIå PARA EL ALèåRITMå DE MAXIMå SECUENCIAL

int maximo(int datos[],int n)

{int m=datos[0],i=1;
do{if(m<datos[i])
{m=datos[i];}
i=i+1;
}while(i<n);
return m;
}

2$
Para el arreglo datos = {3,4,6,2,7,€,10,5}

m 3--> 4--> 6--> 6--> 7--> €--> 10

i 2--> 3--> 4--> 5--> 6--> 7--> $--> €
a[ i ] 4--> 6--> 2--> 7--> €--> 10--> $

El máximo en este caso nos debe dar 10

2€
a

Ejercicio 1. Recursividad

Escribir un procedimiento recursivo que invierta un árbol, que halle su imagen simétrica.
void Refleja(Arbol· T)

{
Arbol· Ti,Td;
if(T!=NULL){
Ti=PodarHijoIzqda·(Raiz·(T),T);
Td=PodarHijoDrcha·(Raiz·(T),T);
Refleja(Ti);
InsertarHijoDrcha·(Raiz·(T),Ti,T);
Refleja(Td);
InsertarHijoIzqda·(Raiz·(T),Td,T);
}
}

Ejercicio 2.Nivel del nodo

Dado un árbol binario de b squeda, escribir una función que devuelva el nivel del nodo con
mayor clave. Hacer lo mismo para un árbol binario que no sea de b squeda.

int numero(Nodo· n,Arbol· T)

{
if (n==NULL)
return 0;
else
return 1+numero(HijoIzqda·(n,T),T)+numero(HijoDrcha·(n,T),T);
}

Ejercicio 3. Claves Repetidas

Disponemos de un árbol binario de b squeda que puede contener claves repetidas, y la

inserción de tales claves se hizo a veces en el izquierdo y otras en el derecho. Se pide
codificar una función recursiva que dado un árbol como el anterior, determine si existen
claves repetidas o no.

Recorriendo en orden central, comparamos con la actual la clave anterior para ver si está
repetida.

30
#include<iostream>
#include<conio.h>
#define tam 1000
using namespace std;
bool esEntero(char *cad)
{
bool num=true;
if(atoi(cad) == 0 && cad[0] != '0')
num=false;
int cade=atoi(cad);
if(cade<-1000000000||cade>1000000000)
num=false;
return num;
}
int main()
{
char opc,num[10];
int nodo[tam],i=0,resp=0;
bool salir=true;
do{
system("cls");
cout<<"\tArbol\n\n";
cout<<"\t1) Agregar al arbol\n";
cout<<"\t2) ·alance del arbol\n";
cout<<"\t3) Eliminar\n";
cout<<"\t4) Mostrar\n";
cout<<"\t5) Salir\n";
cout<<endl<<"\tElige una opcion: ";
cin>>opc;
switch(opc)
{
case '1':
system("cls");
do{
cout<<"\n\tIngresa un numero entero: ";
cin>>num;
}while(!esEntero(num));
nodo[i]=atoi(num);
i++;
getch();
break;
case '2':
system("cls");
for(int j=0;j<i-1;j++)

31
 {
for(int k=0;k<i-1;k++)
{
if(nodo[k]>nodo[k+1])
{
resp=nodo[k+1];
nodo[k+1]=nodo[k];
nodo[k]=resp;
}
}
}
cout<<"\n\tEl arbol se ha balanceado.";
getch();
break;
case '3':
system("cls");
nodo[i]=0;
i--;
cout<<"\tSe borro la ultima captura.";
getch();
break;
case '4':
system("cls");
for(int h=0;h<i;h++)
{
cout<<"\t"<<nodo[h];
if(h<i-1)
cout<<"\n";
} getch();
break;
case '5':
salir=false;
system("cls");
cout<<"\n\t·YE"<<endl;
getch();
break;
default:
cout<<"\tIntroduce una opcion correcta\n";
getch();
}
}
while(salir==true);
getch();
}

32
Ejercicio 4. Hojas de un árbol

Escribir una función recursiva que calcule el n mero de hojas que hay en un árbol.

int numeroH(nodo *a){

int num;
if(a!=NULL){
if(a->der==a->izq)
num=1;
else
num=numeroH(a->der)+numeroH(a->izq);
}else
num=0;
return num;
}
Ejercicio 5. Hojas de un árbol

Implementar una función que diga si dos árboles binarios son iguales.

bool igual(nodo *a, nodo *b){

bool iguales=false;
if(a==NULL && b==NULL)
iguales=false;
else
if((a==NULL && b!=NULL) || (a!=NULL && b==NULL))
iguales=false;
else
if(a->num!=b->num)
iguales=false;
else
iguales=igual(a->izq,b->izq) and igual(a->der,b->der);
return iguales;
}

33
Ejercicio 6. Hojas al mismo nivel

Dada la misma declaración de árbol, escribir una función ·ååLEANA que determine si
todas las hojas del árbol están al mismo nivel.

bool hoja_nivel(arbol:tarbol){
int nivel;
nivel=0;
hoja_nivel=mismo_nivel(a*,nivel,1)
}
bool mismo_nivel(arbol:tarbol,int primera, int nivelact){
if(arbol==NIL)
mismo_nivel:=true;
else if((arbol^.izq==NIL)&&(arbol^.der==NIL))
if(primera=0)
primera=nivelact;
else if((primera<nivelact)||(primera>nivelact))
mismo_nivel:=fal;
else
mismo_nivel:=true;
else if(mismo_nivel(arbol^.izq,primera,nivelact+1))
mismo_nivel=mismo_nivel(arbol^.der,primera,nivelact+1);
}

Ejercicio 7. Numero k-esimo menor

Codificar una función recursiva que recibiendo como parámetro un árbol binario de
b squeda de N nodos y un n mero entero K menor o igual que N, devuelve el K-esimo
n mero más pequeño del árbol.
No se puede utilizar ninguna estructura auxiliar. No existen n meros repetidos en el árbol.
La llamada a la función seria:
Contador:=0;
Numero:=Kesimo(Arbol,k,Cont);
int kesimo(arbol:tarbol;int k;int contador){
contador=0;
int numero=kesimo(arbol,k,contador);
if((arbol<NIL)||(arbol>NIL)){
kesimo=kesimo(arbol^izq,k,contador);
if(contador<k){
contador=contador+1;
if(contador==k)
kesimo=arbol^.clave;
else kesimo=kesimo(arbol^.der,k,contador);
}

34
 }
}

Ejercicio 8. Arbol dentro de un arbol

Con la declaración de arbol del anterior ejercicio, implementar un algoritmo que

determine si un árbol A está incluido en otro árbol ·, es decir, todas las claves del árbol A
están en · con la misma topología. Va a empezar por el árbol entero y va a acabar cuando
la raiz del subarbol 2 sea igual a la clave del arbol 1.

incluir(A1,A2:Tarbol):·ååLEAN{
if (A2==NIL)
incluir = False;
if (A1^.Clave>A2^.Clave)
incluir=incluir(A1^.izda,A2);
if (A1^.Clave<A2^.Clave)
incluir:=incluir(A1^.dcha,A2);
else
incluir:=Igual(A1,A2);
}
igual(A1,A2:Tarbol):·ååLEAN{
if (A2==NIL)
igual=True;
if (A1==NIL)
igual=False;
if (A1^.Clave=A2^.Clave)
igual=igual(A1^.izda,A2^.izda)&&igual(A1^.dcha,A2^.dcha);
else
igual=False;
}

35
Ejercicio 9. Arbol multicamino

Dada esa declaración de tipo, se pide codificar una fución recursiva que recibiendo un
puntero del tipo Tarbol que apunta a un arbol multicamino, que se sabe que es de
b squeda, determine si dicho árbol cumple las caracteristicas de un arbol ·.Cada página
del árbol nicamente podrá ser visitada una vez.

@‘ N <= N mero de claves <= 2N

@‘ Si una página tiene N claves, tiene N+1 descendientes
@‘ Todas las páginas hoja al mismo nivel
Las dos ltimas condiciones son en realidad la misma.
float Esb (Arbol:Tarbol; int i; int aux)
{
aux=bool;
if (Arbol=NIL)
{
Nivel=0;
else(Esb = Nivel)
Esb =NivelAux;
else if (NivelAux=1) || (Arbol^.Numclave>=n)
nivel = TRUE;
else
nivel = FALSE;
}
Aux = TRUE;
for(i =0; i<aux; i++)
{
Aux = (Aux && Esb (Arbol Descend[i], Nivel, NivelAux + 1))
Esb = Aux;
}
else
Esb = FALSE;
}

36
Ejercicio 10. Búsqueda de una clave

Se busca la clave hasta que la encontremos o estemos situados sobre un nodo que sea
una hoja.

@‘ Nodo cualquiera ----> ·ajar

@‘ Nodo clave ----> Contar
@‘ Hoja clave ----> Contar
@‘ Hoja cualquiera ----> Eliminar

int hojas(arbol:tarbol;clave:tclave)
aux:tarbol;
int n_hojas(arbol:tarbol){
if(tarbol==NIL)
n_hojas=0;
else if((arbol^.izq=NIL)&&(arbol^.der=NIL))
n_hojas=1;
else n_hojas:=n_hojas(arbol^.izq)+n_hojas(arbol^.der);
}
{
if(arbol==NIL)
hojas=0;
else if(arbol^.clave:=clave)
hojas:=n_hojas(arbol^.izq)+n_hojas(arbol^.der);
else if((arbol^der=NIL)&&(arbol^izq=NIL)){
aux:=arbol;
arbol:=NIL
aux=0;
hojas:=0;
}
else hojas:=hojas(arbol^.izq,clave)+hojas(arbol^.der,clave);
}

37
 
 
En este 3er parcial utilizamos todo lo aprendido en el semestre. Nos sirvió para poder
diseñar algoritmos mas elaborados además de aplicar estos para la solución de problemas.

El trabajo en equipo fue indispensable ya que sin la colaboración de todos en este trabajo
no se hubiera podido realizar.

En base a conocimientos previos de la materia de estructura de datos, pudimos aplicar

nuestros conocimientos y enriquecerlos, en la utilización de nuevas aplicaciones y herramientas
consiguiendo así un medio factible y eficiente para su resolución rápida y oportuna.

Con el trabajo realizado se pudo tener un mejor entendimiento, sobre las materias que a
futuro cursaremos los ingenieros en informática y los licenciados en ciencias de la informática.

Finalmente agradecemos al profesor Carlos Jes s Carrillo, por haber compartido su

conocimiento de una manera clara y precisa, la cual nos dará experiencia para futuras materias y
un trabajo que podamos desempeñar de una manera adecuada.

èracias.

3$
·

 


@‘ www.uam.edu.mx

@‘ www.ccm.itesm.mx/informatica

@‘ Polilibro de Algoritmos Computacionales

@‘ http://www.slideshare.com/arboles

@‘ Estructura de datos y algoritmos

Alfred V.
Ed. Pearson Addison Longman

@‘ Java
Ed. Alfaomega, 3° edición

3€