LIstas Pilas Colas Recursividad

Listas Pilas - Colas.
Resumen
1

CONTENIDO

1 ESTRUCTURAS DINMICAS DE DATOS. ..................................................... 4
1.1 LISTAS SIMPLEMENTE LIGADAS. .......................................................... 4
1.2 LISTAS DOBLEMENTE ENLAZADAS ...................................................... 6
1.3 LISTAS SIMPLEMENTE LIGADAS CIRCULARES ................................... 7
1.4 LISTAS SIMPLEMENTE LIGADAS CON REGISTRO CABEZA ............... 8
1.5 LISTAS SIMPLEMENTE LIGADAS CIRCULARES CON REGISTRO
CABEZA .................................................................................................... 8
1.6 LISTAS DOBLEMENTE LIGADAS CIRCULARES .................................... 9
1.7 LISTAS DOBLEMENTE LIGADAS CON REGISTRO CABEZA ................ 9
1.8 LISTAS DOBLEMENTE LIGADAS CIRCULARES CON REGISTRO
CABEZA .................................................................................................. 10
1.9 PILAS ...................................................................................................... 10
1.10 COLAS (FILAS) ....................................................................................... 11
2 ALGUNOS TIPS ............................................................................................. 12
3 ALGORITMOS ............................................................................................... 13
3.1 LISTAS SIMPLEMENTE LIGADAS ......................................................... 13
3.1.1 Subprograma que recorre una lista simplemente ligada ................... 13
3.1.2 Subprograma que inserta en una lista simplemente ligada
ordenada (manteniendo el orden) ..................................................... 13
3.1.3 Subprograma (funcin) que busca donde insertar en una lista
simplemente ligada (ordenada) ......................................................... 14
siempre al principio. .......................................................................... 14
siempre al final. ................................................................................. 15
3.1.6 Subprograma (funcin) que busca el ltimo nodo de una lista
simplemente ligada ........................................................................... 15
3.1.7 Subprograma que busca un dato en una lista simplemente ligada
(no ordenada) .................................................................................... 16
3.1.8 Subprograma que borra un dato de una lista simplemente ligada. ... 16
3.2 LISTAS SIMPLEMENTE LIGADAS CIRCULARES ................................. 17
3.2.1 Subprograma que recorre una lista simplemente ligada circular ....... 17
3.2.2 Subprograma que inserta en una lista simplemente ligada circular
simplemente ligada circular (ordenada) ............................................ 18
CABEZA .................................................................................................. 19
3.3.1 Subprograma que recorre una lista simplemente ligada circular
con registro cabeza ........................................................................... 19
3.3.2 Subprograma que inserta en una lista simplemente ligada circular
con registro cabeza, ordenada (manteniendo el orden) .................... 19

Listas Pilas - Colas. Resumen
2
simplemente ligada circular con registro cabeza (ordenada) ............ 20
3.3.4 Subprograma que busca un dato en una lista simplemente ligada
(no ordenada) .................................................................................... 20
3.3.5 Subprograma que borra un dato de una lista simplemente ligada
circular con registro cabeza .............................................................. 21
3.4 LISTAS DOBLEMENTE LIGADAS .......................................................... 22
3.4.1 Subprograma que recorre una lista doblemente ligada de
izquierda a derecha ........................................................................... 22
3.4.2 Subprograma que recorre una lista doblemente ligada de derecha
a izquierda ......................................................................................... 22
3.4.3 Subprograma que inserta en una lista doblemente ligada
doblemente ligada (ordenada) .......................................................... 23
3.4.5 Subprograma que inserta en una lista doblemente ligada siempre
al principio. ........................................................................................ 24
3.4.6 Subprograma que inserta en una lista doblemente ligada siempre
al final. ............................................................................................... 24
doblemente ligada ............................................................................. 25
3.4.8 Subprograma que busca un dato en una lista doblemente ligada
(no ordenada) .................................................................................... 25
3.4.9 Subprograma que borra un dato de una lista doblemente ligada. ..... 26
3.5 LISTAS DOBLEMENTE LIGADAS CIRCULARES .................................. 27
3.5.1 Subprograma que recorre una lista doblemente ligada circular
izquierda a derecha ........................................................................... 27
derecha a izquierda ........................................................................... 27
3.5.3 Subprograma que inserta en una lista doblemente ligada circular
doblemente ligada circular (ordenada) .............................................. 28
CABEZA .................................................................................................. 30
3.6.1 Subprograma que recorre una lista doblemente ligada circular con
registro cabeza de izquierda a derecha ............................................ 30
3.6.2 Subprograma que recorre una lista doblemente ligada circular con
registro cabeza de derecha a izquierda ............................................ 30
3.6.3 Subprograma que inserta en una lista doblemente ligada circular
con registro cabeza, ordenada (manteniendo el orden) .................... 30
doblemente ligada circular con registro cabeza (ordenada) .............. 31
3.6.5 Subprograma que busca un dato en una lista doblemente ligada
(no ordenada) .................................................................................... 31
3.6.6 Subprograma que borra un dato de una lista doblemente ligada
circular con registro cabeza .............................................................. 32

3
4 NOTAS ........................................................................................................... 33
5 RECURSIVIDAD ............................................................................................ 34
5.1 Nmeros de Fibonacci ............................................................................. 36
5.2 Considere la siguiente ecuacin recurrente: ............................................ 37
5.3 Considere las siguientes sucesiones: ...................................................... 38
5.4 Definicin recursiva para elevar un nmero a una potencia: ................... 39
5.5 Nmero de Combinaciones ..................................................................... 39
5.6 Algoritmo de Euclides .............................................................................. 39
5.7 Tcnica de diseo dividir para vencer ................................................... 40

4

1 ESTRUCTURAS DINMICAS DE DATOS.

Las estructuras dinmicas de datos son estructuras que crecen a medida que
ejecuta un programa. Una estructura dinmica de datos es una coleccin de
elementos llamadas nodos - que son normalmente registros. Al contrario de un
arreglo que contiene espacio para almacenar un nmero fijo de elementos, una
estructura dinmica de datos se ampla y contrae durante la ejecucin del
programa, basada en los registros de almacenamiento de datos del programa.

Las estructuras dinmicas de datos se pueden dividir en dos grandes grupos:

- Lineales
o Pilas.
o Colas.
o Listas enlazadas.

- No lineales
o rboles.
o Grafos.

Las estructuras dinmicas de datos se utilizan para almacenamiento de datos del
mundo real, que estn cambiando constantemente. Un ejemplo tpico, es la lista
de pasajeros de una lnea area. Si esta lista se mantuviera en orden alfabtico en
un arreglo, sera necesario hacer espacio para insertar un nuevo pasajero por
orden alfabtico. Esto requiere utilizar un ciclo para copiar los datos del registro de
cada pasajero al siguiente elemento del arreglo. Si en su lugar se utilizar una
estructura dinmica de datos, los nuevos datos del pasajero se pueden insertar
simplemente entre dos registros existentes con un mnimo de esfuerzo.

1.1 LISTAS SIMPLEMENTE LIGADAS.

Una lista enlazada o encadenada es un conjunto de elementos en los que cada
uno contiene la posicin o direccin de memoria del siguiente elemento de la lista.
Cada elemento de la lista encadenada debe tener al menos dos campos: Un
campo que tiene el valor del elemento y un campo (enlace o link) que contiene la
posicin del siguiente elemento, es decir, su conexin, enlace o encadenamiento.
Los elementos de una lista son enlazados por medio de los campos enlaces.

Las listas encadenadas tienen una terminologa propia que se suele utilizar
normalmente. Primero, los valores se almacenan en un nodo.

5

Los componentes de un nodo se llaman campos. Un nodo tiene al menos un
campo de dato o valor y un enlace (indicador o puntero) con el siguiente campo. El
campo enlace apunta (proporciona la direccin de) al siguiente nodo de la lista. El
ultimo nodo de la lista encadenada, por convenio, se suele representar por un
enlace con la palabra Null (nulo), una barra inclinada, el nmero cero (0), y en
ocasiones, el smbolo elctrico de tierra o masa.

Una lista enlazada o encadenada es una lista que se construye empleando
apuntadores. Adems, no tiene un tamao fijo, sino que puede crecer y decrecer
durante la ejecucin del programa. Se constituyen como variables dinmicas.

En las listas enlazadas no es necesario que los elementos en la lista sean
almacenados en posiciones fsicas adyacentes, ya que el apuntador indica dnde
se encuentra el siguiente elemento de la lista.

Por consiguiente, la insercin y borrado no exigen desplazamiento como en el
caso de las listas contiguas o vectores.

Para eliminar un elemento de una lista enlazada, solo es necesario cambiar el
puntero del elemento anterior al elemento siguiente del que deseamos eliminar.
Para insertar un elemento en determinada posicin, solo necesitamos cambiar el
apuntador de la posicin anterior a donde queremos insertar a nuestro nuevo

6
elemento y este elemento deber direccionar el elemento al que anteriormente
apuntaba el elemento que qued antes del nuevo elemento.

Una lista enlazada sin ningn elemento se llama lista vaca. Su puntero inicial o de
cabecera tiene el valor nulo (nil o Null) o cero.

Una lista enlazada se puede definir por:

- El tipo de sus elementos: campo de informacin (datos) y campo enlace
(puntero).
- Un puntero de cabecera que permite acceder al primer elemento de la lista.
- Un medio para detectar el ltimo elemento de la lista: puntero nulo (nil) o
cero.

Las operaciones que hay que realizar con una lista enlazada son:

- Definir y crear la lista.
- Recorrer los nodos de una lista enlazada.
- Agregar un nodo a la lista.
1. Al final.
2. Al Principio.
3. En el centro.
- Eliminar un nodo de la lista.
1. Al final.
2. Al Principio.
3. En el centro.

1.2 LISTAS DOBLEMENTE ENLAZADAS

Una lista doblemente enlazada o encadenada es un conjunto de elementos en los
que cada elemento adems de contener la posicin o direccin del siguiente
elemento de la lista, contiene la direccin del anterior elemento en la lista. Cada
elemento de la lista doblemente encadenada debe tener al menos tres campos:
Un campo que tiene el valor del elemento y dos campos (enlaces o links) que
contiene la posicin del anterior y siguiente elemento, es decir, su conexin,
enlace o encadenamiento. Los elementos de una lista son enlazados por medio de
los campos enlaces.

7

En este tipo de listas el recorrido se puede hacer en dos direcciones: de izquierda
a derecha y de derecha a izquierda. Para poder lograr esto el diseo de los nodos
se hace con dos campos de enlace: uno que llamaremos Liga Izquierda (LI) y otro
que llamaremos Liga Derecha (LD). Un esquema general de dicho nodo es:

LIGA
IZQUIERDA
AREA DE
DATOS
LIGA
DERECHA

LI(X) X LD(X)

LI(X): Apunta hacia el registro anterior a X
LD(X): Apunta hacia el registro siguiente a X

La propiedad fundamental de las listas doblemente ligadas es:

LD(LI(X)) = X = LI(LD(X))

1.3 LISTAS SIMPLEMENTE LIGADAS CIRCULARES

Una lista simplemente enlazada o encadenada circular es un conjunto de
elementos en los que el ltimo nodo en vez de contener un indicador de fin tiene
la direccin de memoria del primer nodo o cabeza.

ANT INFO SIG
Null

ANT INFO SIG

ANT INFO SIG

ANT INFO SIG
Null
INFO SIG

INFO SIG

INFO SIG

INFO SIG

PRIMERO
PRIMERO

8
1.4 LISTAS SIMPLEMENTE LIGADAS CON REGISTRO CABEZA

El registro cabeza es un registro (NODO) que, por lo general, no tendr ningn
valor en su(s) campo(s) de informacin y siempre ser el primer nodo de la lista
ligada facilitando as las operaciones de insercin, borrado, recorrido y hasta la
creacin.

Para recorrer la lista se inicia en el segundo nodo, es decir, a p se le asigna la
Liga(L).

La lista est vaca cuando la liga del primer nodo (registro cabeza) es nil (Null,
Nulo 0)

La creacin de este tipo de lista vara con respecto a aquellas en las que no existe
el registro cabeza, en las cuales basta con asignarle 0, Nil, Null o Nulo a una
variable L, en que es necesario crear un nuevo nodo y asignarle Null en el campo
de informacin, as:

Struct NODO {
Dato Numrico
Liga Apuntador
}

X = New_Nodo( )
L = X
Dato(X) = Null
Liga(X) = Null

CABEZA

La diferencia de este tipo de lista con la anterior est en que el ltimo nodo de las
circulares apunta a la cabeza (registro cabeza).

De igual manera para recorrer la lista se inicia en el segundo nodo, es decir, a p
se le asigna la Liga(L) y se termina de recorrer cuando p sea igual a L.

S la lista est vaca, inicialmente p queda valiendo L, y su creacin se hace de la
siguiente manera:

9
Struct NODO {
Dato Numrico
Liga Apuntador
}

X = New_Nodo( )
L = X
Dato(X) = Null
Liga(X) = X

1.6 LISTAS DOBLEMENTE LIGADAS CIRCULARES

En las listas doblemente ligadas circulares el campo de liga derecha del ltimo
nodo apunta hacia el primer Nodo de la lista y el campo de la liga izquierda del
primer modo apunta hacia el ltimo registro de la lista.

1.7 LISTAS DOBLEMENTE LIGADAS CON REGISTRO CABEZA

En las listas doblemente ligadas NO circulares el campo de datos del primer nodo
(registro cabeza) lleva como valor Null y la liga derecha apunta hacia el primer
Nodo que contiene informacin en la lista.

En caso de estar la lista vaca la liga derecha tendr por valor Nil, Null, Nulo 0.

Para crear la lista se definen las siguientes instrucciones:

Struct NODO {
Dato Numrico
LI Apuntador
LD Apuntador
}

X = New_Nodo( )
L = X
Dato(X) = Null
LI(X) = Null
LD(X) = Null

10
CABEZA

En las listas doblemente ligadas circulares el campo de datos del primer nodo
(registro cabeza) lleva como valor Null, y tanto la liga izquierda como la derecha
apuntan hacia si misma cuando la lista est vaca.

Para crear la lista se definen las siguientes instrucciones:

Struct NODO {
Dato Numrico
LI Apuntador
LD Apuntador
}

X = New_Nodo( )
L = X
Dato(X) = Null
LI(X) = X
LD(X) = X

1.9 PILAS

Es una estructura de datos especial en donde la insercin y el borrado de los
nuevos elementos se realizan slo por un extremo que se denomina cima o tope.
Esta estructura posee numerosas analogas en la vida real, por ejemplo imagine
una pila de platos.

Dado que las operaciones de insertar y eliminar se realizan por un solo extremo (el
superior), los elementos solo pueden eliminarse en orden inverso al que se
insertan en la pila. El ltimo elemento que se pone en la pila es el primero en
sacar; dado a esto a estas estructuras se les conoce con el nombre de LIFO.

Las operaciones que se pueden realizar con una pila son:

- PUSH (pila, elemento): Introduce un elemento en la pila. Tambin se le
conoce como poner o meter.
- POP (pila): Elimina un elemento de la pila. Tambin se le conoce como
sacar o quitar.
- VACIA(pila): Funcin booleana que indica si la pila esta vaca o no.

Las pilas se pueden implementar por arreglos o bien por punteros siempre y
cuando se respete el concepto antes mencionado.

11

Idealmente, una pila puede contener un nmero ilimitado de elementos y no
producir nunca desbordamiento. En la prctica, sin embargo, el espacio de
almacenamiento disponible es finito. La codificacin de una pila requiere un cierto
equilibrio, ya que si la longitud mxima es demasiado grande, se gasta mucha
memoria, mientras que un valor pequeo de longitud mxima producir
desbordamientos frecuentes.

1.10 COLAS (FILAS)

Las colas o filas son otro tipo de estructura lineal de datos, similares a las pilas,
diferencindose de ellas en el modo de insertar eliminar elementos.

Una cola es una estructura lineal de datos en la que las eliminaciones se realizan
al principio de la lista, y las inserciones se realizan por el final de la misma. En las
colas el elemento que entr primero tambin sale primero, por ello se conocen
como estructuras FIFO. As pues la diferencia con las pilas es solamente el modo
de entrada y salida de datos.

En la vida real se tienen ejemplos numerosos de colas: la cola de un autobs, la
cola de un cine, etc. En todas ellas el primer elemento que llega es el primero que
sale. En informtica existen tambin numerosas aplicaciones de colas. Por
ejemplo, en un sistema de tiempo compartido suele haber un procesador central y
una serie de perifricos compartidos: discos, impresoras, etc. Los recursos se
comparten por los diferentes usuarios y se utiliza una cola para almacenar los
programas o peticiones de los usuarios que esperan su turno de ejecucin.

Las colas se pueden representar como estructuras dinmicas de datos o como
arreglos.

Las operaciones que se pueden realizar con una cola son:

- Acceder al primer elemento de la cola.
- Aadir un elemento al final de la cola.
- Eliminar el primer elemento de la cola.
- Vaciar la cola.
- Verificar el estado de la cola.

12
2 ALGUNOS TIPS

- Recuerde que la cabeza de lista no se puede perder

- Si la lista no est creada se deben hacer los siguientes pasos para crearla:
o Definir la estructura de cada nodo (Struct NODO)
o Crear la Lista

- Para Insertar en una lista los pasos son:
o Pedir una copia de la estructura (Solicitar el registro)
o Guardar en el Nodo la informacin dada
o Ligar el Nodo a la Lista. Depende de lo solicitado en el ejercicio (Al
principio, Al final o manteniendo el orden de la lista)

- Para Borrar en una lista es necesario:
o Reconstruir las ligas de la lista soltando (desligando) el Nodo a
borrar
o Liberar la memoria que ocupaba el Nodo

Definicin del NODO para todos los algoritmos de listas simplemente ligadas
a utilizar aqu

Struct NODO {
Dato Numrico
Liga Apuntador
}

Grficamente sera:

Definicin del NODO para todos los algoritmos de listas doblemente ligadas
a utilizar aqu

Struct NODO {
Dato Numrico
LI Apuntador
LD Apuntador
}

Grficamente sera:

DATO LIGA
LI DATO LD

13
3 ALGORITMOS

3.1 LISTAS SIMPLEMENTE LIGADAS
3.1.1 Subprograma que recorre una lista simplemente ligada

RECIBE: L = Cabeza de la lista a recorrer
RETORNA: Nada

Subprograma Recorre_lista(L)
Apuntador P
P = L
MIENTRAS (P <> Null) haga
Escriba dato(p) Ver NOTA_1.
P = liga(P)
Fin MIENTRAS
Fin (recorre_Lista)

ordenada (manteniendo el orden)

d = Dato a Insertar
Y = Direccin del Nodo inmediatamente anterior al
que se va a insertar
RETORNA: Nada

Subprograma Insertar_Lista(L,d)
Apuntador X, Y
X = New_Nodo( ) Ver NOTA_2.
Dato(X) = d
Y = Buscar_donde_Insertar(L,d) Ver NOTA_3.
Si (Y = Null) Entonces
Liga(X) = L
L = X
Sino
Liga(X) = Liga(Y)
Liga(Y) = X
Fin si
Fin (Insertar_Lista)

14
simplemente ligada (ordenada)

RECIBE:
L = Cabeza de la lista a recorrer
d = Dato a Insertar
RETORNA:
que se va a insertar. Si Y = Null, es porque el
dato a insertar es el primero, si Y tiene valor esta
ser la del nodo inmediatamente anterior a la del
nodo insertar (inclusive si es el ltimo)

Subprograma Buscar_Insertar_lista(L,d)
Apuntador P, Y
P = L
Y = Null
MIENTRAS (P <> Null and Dato(P) < d) Haga
Y = P
P = Liga(P)
Fin MIENTRAS
Retorne (Y)
Fin (Buscar_Insertar_lista)

siempre al principio.

d = Dato a Insertar

RETORNA: Nada

Subprograma Insertar_Lista_Inicio(L,d)
Apuntador X
Dato(X) = d
Si (L = Null) Entonces
Liga(X) = Null
Sino
Liga(X) = L
Fin si
L = X
Fin (Insertar_Lista_Inicio)

15
siempre al final.

d = Dato a Insertar

RETORNA: Nada

Subprograma Insertar_Lista_Final(L,d) Ver NOTA_8.
Apuntador X, Ultimo
Dato(X) = d
Liga(X) = Null
L = X
SiNO
Ultimo = Buscar_Ultimo(L) Ver NOTA_7.
Liga(Ultimo) = X
Fin si
Fin (Insertar_Lista_Final)

simplemente ligada

RECIBE:
RETORNA:
Ultimo = Direccin del Ultimo Nodo. Si Ultimo = Null, es
porque la lista est Vacia.

Subprograma Ultimo_Lista (L)
Apuntador Ultimo
Ultimo = L
MIENTRAS ( Liga(Ultimo) <> Null) Haga
Ultimo = Liga(Ultimo)
Fin Mientras
Retorne (Ultimo)
Fin (Ultimo_lista)

16
3.1.7 Subprograma que busca un dato en una lista simplemente
ligada (no ordenada)

RECIBE:
d = Dato buscado
RETORNA:
que se busca. Si Y = Null, es porque el dato
buscado es el primero de la lista.

X = Direccin del Nodo que se busca. Si X = Null, es
porque el dato buscado no existe en la lista.

Subprograma Buscar_dato_lista(L,d,X,Y)
X = L
Y = Null
MIENTRAS (X <> Null AND Dato(X) <> d) Haga
Y = X
X = Liga(X)
Fin MIENTRAS
Fin (Buscar_dato_lista)

3.1.8 Subprograma que borra un dato de una lista simplemente
ligada.

d = Dato a borrar

RETORNA: Nada

Subprograma Borrar_lista(L,d)
Apuntador X,Y
Buscar_dato_lista(L,d,X,Y) Ver NOTA_4.
Si (X = Null) Entonces
Imprima Dato a Borrar no existe
Returne ()
Fin si
L = Liga(L)
Sino
Liga(y) = liga(x)
Fin si
Liberar (X) Ver NOTA_5.
Fin(borrar_Lista)

17
3.2 LISTAS SIMPLEMENTE LIGADAS CIRCULARES
circular

RETORNA: Nada

Subprograma Recorre_lista_Circular(L)
Apuntador P
P = L
Repita
P = liga(P)
MIENTRAS (P <> L)
Fin (recorre_Lista_Circular)

circular ordenada (manteniendo el orden)

d = Dato a Insertar
RETORNA: Nada

Subprograma Insertar_Lista_Circular(L,d)

Apuntador X, Y, U
Dato(X) = d
L = X
Liga(X) = X
SiNo
U = Ultimo_Lista(L) Ver 3.1.6.
Liga(X) = L
Liga(U) = X
L = X
Sino

18
Liga(X) = Liga(Y)
Liga(Y) = X
Fin si
Fin Si
Fin (Insertar_Lista_Circular)

simplemente ligada circular (ordenada)

RECIBE:
d = Dato a Insertar
RETORNA:

Subprograma Buscar_Insertar_lista_circular(L,d)
Apuntador P, Y
P = L
Y = Null
MIENTRAS (P <> L and Dato(P) < d) Haga
Y = P
P = Liga(P)
Fin MIENTRAS
Retorne (Y)
Fin (Buscar_Insertar_lista_circular)

19
CABEZA
circular con registro cabeza

RETORNA: Nada

Apuntador P
P = L
P = liga(P)
Fin MIENTRAS
Fin (recorre_Lista)

circular con registro cabeza, ordenada (manteniendo el orden)

d = Dato a Insertar
RETORNA: Nada

Apuntador X, Y
Dato(X) = d
Liga(X) = Liga(Y)
Liga(Y) = X

20
simplemente ligada circular con registro cabeza (ordenada)

RECIBE:
d = Dato a Insertar
RETORNA:
que se va a insertar.

Apuntador P, Y
P = Liga(L)
Y = L
Y = P
P = Liga(P)
Fin MIENTRAS
Retorne (Y)

3.3.4 Subprograma que busca un dato en una lista simplemente

RECIBE:
d = Dato buscado
RETORNA:
que se busca.

X = Direccin del Nodo que se busca. Si X = L, es

X = Liga(L)
Y = L
MIENTRAS (X <> L AND Dato(X) <> d) Haga
Y = X
X = Liga(X)
Fin MIENTRAS

21
3.3.5 Subprograma que borra un dato de una lista simplemente
ligada circular con registro cabeza

d = Dato a borrar

RETORNA: Nada

Apuntador X,Y
Si (X = L) Entonces
Retorne ()
Fin si
Liga(y) = liga(x)
Fin(borrar_Lista)

22
3.4 LISTAS DOBLEMENTE LIGADAS
izquierda a derecha

RETORNA: Nada

Apuntador P
P = L
P = LD(P)
Fin MIENTRAS
Fin (recorre_Lista)

derecha a izquierda

RETORNA: Nada

Apuntador P
P = Ultimo(L) Ver NOTA_7.
P = LI(P)
Fin MIENTRAS
Fin (recorre_Lista)

ordenada (manteniendo el orden)

d = Dato a Insertar

23
RETORNA: Nada

Apuntador X, Y
Dato(X) = d
Liga(X) = L
L = X
Sino
Liga(X) = Liga(Y)
Liga(Y) = X
Fin si

doblemente ligada (ordenada)

RECIBE:
d = Dato a Insertar
RETORNA:

Apuntador P, Y
P = L
Y = Null
MIENTRAS (P <> Null and Dato(P) < d) Haga
Y = P
P = Liga(P)
Fin MIENTRAS
Retorne (Y)

24
siempre al principio.

d = Dato a Insertar

RETORNA: Nada

Subprograma Insertar_Lista_Inicio(L,d)
Apuntador X
Dato(X) = d
Liga(X) = Null
Sino
Liga(X) = L
Fin si
L = X
Fin (Insertar_Lista_Inicio)

siempre al final.

d = Dato a Insertar

RETORNA: Nada

Subprograma Insertar_Lista_Final(L,d) Ver NOTA_8.
Apuntador X, Ultimo
Dato(X) = d
Liga(X) = Null
L = X
SiNO
Ultimo = Buscar_Ultimo(L) Ver NOTA_7.
Liga(Ultimo) = X
Fin si
Fin (Insertar_Lista_Final)

25
doblemente ligada

RECIBE:
RETORNA:
Ultimo = Direccin del Ultimo Nodo. Si Ultimo = Null, es
porque la lista est Vacia.

Subprograma Ultimo_Lista (L)
Apuntador Ultimo
Ultimo = L
MIENTRAS ( Liga(Ultimo) <> Null) Haga
Ultimo = Liga(Ultimo)
Fin Mientras
Retorne (Ultimo)
Fin (Ultimo_lista)

3.4.8 Subprograma que busca un dato en una lista doblemente

RECIBE:
d = Dato buscado
RETORNA:
que se busca. Si Y = Null, es porque el dato
buscado es el primero de la lista.

X = Direccin del Nodo que se busca. Si X = Null, es

X = L
Y = Null
MIENTRAS (X <> Null AND Dato(X) <> d) Haga
Y = X
X = Liga(X)
Fin MIENTRAS

26
3.4.9 Subprograma que borra un dato de una lista doblemente
ligada.

d = Dato a borrar

RETORNA: Nada

Apuntador X,Y
Si (X = Null) Entonces
Returne ()
Fin si
L = Liga(L)
Sino
Liga(y) = liga(x)
Fin si
Fin(borrar_Lista)

27
3.5 LISTAS DOBLEMENTE LIGADAS CIRCULARES

izquierda a derecha

RETORNA: Nada

Apuntador P
P = L
Repita
Escriba Dato(p) Ver NOTA_1.
P = LD(P)
MIENTRAS (P <> L)

derecha a izquierda

RETORNA: Nada

Apuntador P
P = LI(L)
Repita
Escriba Dato(p) Ver NOTA_1.
P = LI(P)
MIENTRAS (P <> L)

circular ordenada (manteniendo el orden)

d = Dato a Insertar

28
RETORNA: Nada

Subprograma Insertar_Lista_Circular(L,d)

Apuntador X, Y, U
Dato(X) = d
L = X
LI(X) = X
LD(X) = X
SiNo
LD(X) = L
LI(X) = LI(L)
LD(LI(L)) = X
LI(L) = X
L = X
Sino
LD(X) = LD(Y)
LI(X) = Y
LI(LD(Y)) = X
LD(Y) = X
Fin si
Fin Si
Fin (Insertar_Lista_Circular)

doblemente ligada circular (ordenada)

RECIBE:
d = Dato a Insertar
RETORNA:

29
Subprograma Buscar_Insertar_lista_circular(L,d)
Apuntador P, Y
Si (d < dato(L) ) ent
return(Null)
Fin Si
P = LD(L)
Y = L
Y = P
P = LD(P)
Fin MIENTRAS
Retorne (Y)
Fin (Buscar_Insertar_lista_circular)

30
CABEZA
con registro cabeza de izquierda a derecha

RETORNA: Nada

Apuntador P
P = LD(L)
MIENTRAS (P <> L) haga
P = LD(P)
Fin MIENTRAS
Fin (recorre_Lista)

con registro cabeza de derecha a izquierda

RETORNA: Nada

Apuntador P
P = LI(L)
MIENTRAS (P <> L) haga
P = LI(P)
Fin MIENTRAS
Fin (recorre_Lista)

circular con registro cabeza, ordenada (manteniendo el orden)

d = Dato a Insertar

31
RETORNA: Nada

Apuntador X, Y
Dato(X) = d
LD(X) = LD(Y)
LI(X) = Y
LI(LD(X)) = X
LD(Y) = X
doblemente ligada circular con registro cabeza (ordenada)

RECIBE:
d = Dato a Insertar
RETORNA:
que se va a insertar.

Apuntador P, Y
P = LD(L)
Y = L
Y = P
P = LD(P)
Fin MIENTRAS
Retorne (Y)

3.6.5 Subprograma que busca un dato en una lista doblemente

RECIBE:
d = Dato buscado
RETORNA:

32
X = Direccin del Nodo que se busca. Si X = L, es

Subprograma Buscar_dato_lista(L,d)
X = LD(L)
MIENTRAS (X <> L AND Dato(X) <> d) Haga
X = LD(X)
Fin MIENTRAS
Retorne (X)


3.6.6 Subprograma que borra un dato de una lista doblemente
ligada circular con registro cabeza

d = Dato a borrar

RETORNA: Nada

Apuntador X,Y
X = Buscar_dato_lista(L,d) Ver NOTA_4.
Si (X = L) Entonces
Returne ()
Fin si
LD(LI(X)) = LD(X)
LI(LD(X)) = LI(X)
Fin(borrar_Lista)

33
4 NOTAS

NOTA_1: Esta instruccin puede reemplazarse por la que se necesite, por
ejemplo un contador, un acumulador, una comparacin, entre otras. Para
este caso el subprograma recorre una lista e imprime los datos
almacenados en cada nodo.

NOTA_2: Esta instruccin invoca un subprograma que interacta con el
Sistema Operativo solicitndole un registro (una copia de la estructura
NODO definida) y almacenando la direccin en memoria de dicho registro
en la variable tipo Apuntador de nombre X .

NOTA_3: Esta instruccin invoca una funcin que retorna la direccin
donde se debe almacenar el nuevo NODO.

NOTA_4: Esta instruccin invoca un subprograma que busca en la lista
cuya cabeza es L, un dato d, y recibe en X la direccin del Nodo buscado
(Null si no existe) y en Y la direccin del Nodo inmediatamente anterior (Null
si el Nodo es el primero de la lista).

NOTA_5: Esta instruccin invoca un subprograma que interacta con el
Sistema Operativo solicitndole elimine de la memoria un registro (NODO)
el cual se encuentra en la direccin de memoria X .

donde se debe almacenar el nuevo NODO..

donde se encuentra el Ultimo NODO de la Lista.

NOTA_8: Si sabemos que todos los registros a insertar sern siempre al
final, es mas eficiente y prctico utilizar una variable auxiliar tipo apuntador,
que siempre apunte al ltimo registro (NODO) de la lista. Y las
instrucciones para insertar un registro (NODO) son:

Apuntador X, Ultimo
X = New_Nodo( )
Dato(X) = d
Liga(X) = Null
Liga(Ultimo) = X
Ultimo = x Se elimina la Funcin Ultimo_Lista()

34
5 RECURSIVIDAD

Definicin:

La recursividad es un concepto fundamental en matemticas y en
computacin. Una definicin recursiva dice cmo obtener conceptos nuevos
empleando el mismo concepto que intenta describir.

En toda situacin en la cual la respuesta pueda ser expresada como una
secuencia de movimientos, pasos o transformaciones gobernadas por un
conjunto de reglas no ambiguas, la frmula recursiva es un buen candidado
para resolver el problema.

Los razonamientos recursivos se encuentran en la base misma de las
matemticas porque son necesarios para describir conceptos centrales
como el de nmero

EJEMPLOS DE ALGORITMOS RECURSIVOS:

Factorial

Definicin:

factorial (n) = n! si n > 0
factorial (n) = n*n-1*n-2* ... * 1 si n > 0

el valor de 0! se define como

factorial (0) = 1

Su definicin recursiva es:

factorial (n) = 1 si n = 0
factorial (n) = n* factorial (n-1) si n > 0

as para calcular el factorial de 4:

factorial (4) = 4 * factorial (3) = 4 * 6 = 24
factorial (3) = 3 * factorial (2) = 3 *2 = 6

35
FACTORIAL UTILIZANDO CICLOS:

Entero FactorialCiclos(entero n)
InicioMetodo
entero fac = 1;
para (i = 1 hasta n)
InicioPara
Fac = fac * i
FinPara
Retornar fac
FinMetodo

FACTORIAL RECURSIVO:

Entero FactorialRecursivo(entero n){
Si (n = 0)
Verdadero
Retornar 1;
Falso
Retornar FactorialRecursivo(n - 1) * n
Fin-Si
}

Las definiciones recursivas de funciones en matemticas que tienen como
argumentos nmeros enteros, se llaman relaciones de recurrencia.

Forma de una ecuacin de recurrencia:

c
o
a
r
+c
1
a
r-1
+ c
2
a
r-2
+ ....+ c
k
a
r-k
= f(r) funcin matemtica discreta

donde c
i
son constantes, es llamada una ecuacin de recurrencia de coeficientes
constantes de orden k, condicionada a que c
0
y c
k
= 0.

Una definicin recursiva dice cmo obtener conceptos nuevos empleando el
mismo concepto que intenta definir.

El poder de la recursividad es que los procedimientos o conceptos complejos
pueden expresarse de una forma simple.

Un razonamiento recursivo tiene dos partes: la base y la regla recursiva de
construccin. La base no es recursiva y es el punto tanto de partida como de
terminacin de la definicin.

36
Ejemplo:

Base: La secuenciacin, iteracin condicional y seleccin son estructuras
vlidas de control que pueden ser consideradas como enunciados.

Regla recursiva: Las estructuras de control que se pueden formar
combinando de manera vlida la secuenciacin iteracin condicional y seleccin
tambin son vlidos.

Un conjunto de objetos est definido recursivamente siempre que:

(B) algunos elementos del conjunto se especifican explcitamente
(R) el resto de los elementos del conjunto se definen en trminos de los
elementos ya definidos

donde
(B) se llama base
(R) se llama clusula recursiva

Observaciones:

1. El procedimiento se llama a si mismo
2. El problema se resuelve, resolviendo el mismo problema pero de tamao menor
3. La manera en la cual el tamao del problema disminuye asegura que el caso
base eventualmente se alcanzar

La recursividad es un mtodo poderoso usado en inteligencia artificial, su poder es
que algunos conceptos complejos pueden expresarse en una forma simple. Una
definicin recursiva difiere de una definicin circular en que tiene una forma de
escapar de su expansin infinita. Este escape se encuentra en la definicin o
porcin no recursiva o terminal de la definicin.

Las frmulas recursivas pueden aplicarse a situaciones tales como prueba de
teoremas, solucin de problemas combinatorios, algunos acertijos, etc.

Ejemplos:

5.1 Nmeros de Fibonacci

Los nmeros de Fibonacci se definen como:

F
N
= F
N-1
+ F
N-2
para N > 2
F
0
= F
1
= 1

que definen la secuencia:

37

1,1,2,3,5,8,13,21,34,55,89,144, .....

Por ejemplo, si quisiramos encontrar Fibonacci de 5, entonces:

Fibonacci (5) = Fibonacci (4) + Fibonacci (3)

De manera iterativa el algoritmo podra ser:

esttica int Fibonacci (int n)
// versin iterativa
comienza
fibo [0] 1
fibo [1] 1
para i 1 hasta n
fibo [i] fibo [i-1]+ fibo [i-2]
regresa fibo [n]
termina

Resolviendo el mismo problema pero de manera recursiva, obtenemos:

esttica int Fibonacci (int n)
//versin recursiva
comienza
si n < 1 entonces
regresa 1
otro
regresa Fibonacci (n-1) + Fibonacci (n-2)
termina

5.2 Considere la siguiente ecuacin recurrente:

a
n
= a
n-1
+ 2
n

a
0
= 1

esttica int a (int n)
comienza
si n = 0 entonces
regresa1
otro
regresa 2^n + a (n-1)
termina

38
Los valores de los trminos de una sucesin pueden darse de manera explcita
mediante frmulas como:

S
n
= n
4
- 3n
3
- 2n

pero tambin pueden definirse por medio de descripciones que involucren otros
trminos que les anteceden en la sucesin.

5.3 Considere las siguientes sucesiones:

a) Sum (n) =
1
0
i
i
i n
!
=
=

b) Sum (0) = 1
Sum (n+1) = Sum (n) + 1/(1/(n+1)!)

c) Seq (0) = 1
Seq (n+1) = (n+1) / Seq(n)

d) T (1) = 1
T (n) = 2T (n div 2)

e)

=
=
+
=
n i
a i
n
a i
i n
i
i
n < a si
a = i si
1

por ejemplo:

i
i
i n
=
=
=
1
1

i i i i i
i
i
i
i
i
i
i
i
i
i
= + = + + = + + + = + + + + = + + + + =
=
=
=
=
=
=
=
=
=
=
5 5 4 5 4 3 5 4 3 2 5 4 3 2 1 15
1
1
1
2
2
3
2
4
2
5

esttica int suma (int i, int n)
comienza
si i = n entonces
regresa i
otro
regresa n + suma (i,n-1)
termina

39
5.4 Definicin recursiva para elevar un nmero a una potencia:

Un nmero elevado a la potencia cero produce la unidad; la potencia de un
nmero se obtiene multiplicndolo por s mismo elevando a la potencia menos
uno. Por ejemplo:

3
2
= 3*(3
1
) = 3*(3*3
0
) = 3*(3*1)= 3*(3) = 9

esttica int potencia (int n, int k)
comienza
si k=0 entonces
regresa 1
otro
regresa n * potencia (n,k-1)
termina

5.5 Nmero de Combinaciones

Recursivamente, podemos definir el nmero de combinaciones de m objetos
tomados de n, denotado (n,m) para n> 1 y 0 < m < n por:

(n,m) = 1 si m = 0 m = n n = 1
(n,m) = (n-1, m) + (n-1,m-1) en otro caso

esttica int combinaciones (int n, int m)
comienza
si m = 0 o m = n o n = 1 entonces
regresa 1
otro
regresa combinaciones (n-1,m) + combinaciones (n-1,m-1)
termina

5.6 Algoritmo de Euclides

Este algoritmo es considerado el ms viejo no trivial.

El paso esencial que garantiza la validez del algoritmo consiste en mostrar que el
mximo comn divisor (mcd) de a y b, (a > b > 0), es igual a a si b es cero, en otro
caso es igual al mcd de b y el remanente de a dividido por b, si b > 0.

40
esttica int mcd (int a,b)
comienza
si b = 0
regresa a
otro
regresa mcd (b, a mod b)
termina

Ejemplos:

mcd (25, 5) = mcd (5,0) = 5
mcd (18,6) = mcd (6,0) = 6
mcd (57, 23) = mcd (23, 1) = mcd (1,0) = 1
mcd (35, 16) = mcd (16,3) = mcd (3, 1) = mcd (1, 0) = 1

Definicin: Cuando una llamada recursiva es la ltima posicin ejecutada del
procedimiento se llama recursividad de cola, recursividad de extremo final o
recursin de extremo de cola.

Definicin: Cuando un procedimiento incluye una llamada a si mismo se conoce
como recursin directa.

Definicin: Cuando un procedimiento llama a otro procedimiento y este causa que
el procedimiento original sea invocado, se conoce como recursin indirecta.

Al principio algunas personas se sienten un poco incmodas con la recursividad,
tal vez porque da la impresin de ser un ciclo infinito, pero en realidad es menos
peligrosa una recursin infinita que un ciclo infinito, ya que una recursividad infinita
pronto se queda sin espacio y termina el programa, mientras que la iteracin
infinita puede continuar mientras no se termine en forma manual.

Cuando un procedimiento recursivo se llama recursivamente a si mismo varias
veces, para cada llamada se crean copias independientes de las variables
declaradas en el procedimiento.

5.7 Tcnica de diseo dividir para vencer

Muchas veces es posible dividir un problema en subproblemas ms pequeos,
generalmente del mismo tamao, resolver los subproblemas y entonces combinar
sus soluciones para obtener la solucin del problema original.

Como los subproblemas obtenidos generalmente son del mismo tipo que el
problema original, la estrategia dividir para vencer generalmente se implementa
como un algoritmo recursivo.

Solucin DPV (Problema T)

41
comienza
si T < pequeo entonces
regresa solucinTrivial (T)
otro
comienza
divide (T,T
1
,T
2
, ..., T
a
)
para i 1 hasta a
Solucin
i
a DPV (T
i
)
regresa combina (Solucin
1
, Solucin
2
, ... , Solucin
a
)
termina
termina

Dividir para vencer es una tcnica natural para las estructuras de datos, ya que
por definicin estn compuestas por piezas. Cuando una estructura de tamao
finito se divide, las ltimas piezas ya no podrn ser divididas.

Ejemplos:

1. Encontrar el nmero mayor de un arreglo de enteros:

esttica int mayor1 (objeto [ ] A, int limIzq, int limDer)
comienza
si limIzq = limDer entonces
regresa A[limIzq]
otro
comienza
m (limIzq + limDer) div 2
mayorIzq mayor1 (A,limIzq,m)
mayorDer mayor1 (A, m +1, limDer)
si mayorIzq > mayorDer entonces
mayor1 mayorIzq
otro
regresa mayorDer
termina
termina

Otra forma de resolver este problema es la siguiente:

42
esttica int mayor1 (objeto [ ] A, int limIzq, int limDer)
//versin 2
comienza
regresa A[limIzq]
otro
comienza
mayorIzq mayor1 (A, limIzq, m)
mayorDer mayor1 (A, m +1, limDer)
si mayorIzq > mayorDer entonces
regresa mayorIzq
otro
regresa mayorDer
termina
termina

esttica int mayor2 (objeto [ ] A, int limIzq)
comienza
limDer = A.longitud-1
regresa A[limIzq]
otro
si limDer-limIzq = 1 entonces
si A[limDer] > A[limIzq] entonces
regresa A[limDer]
otro
regresa A[limIzq]
otro
comienza
m mayor2 (A,limIzq+1)
si A[limIzq] > m entonces
regresa A[limIzq]
otro
regresa m
termina
termina

2. Inversin de una cadena

esttica Cad invierte (Cad cadena, int limIzq, int limDer)
comienza
si limDer = limIzq entonces
regresa cadena
otro
regresa invierte (cadena, limDer,limIzq+1) + cadena [limIzq]
termina

43

3. Cadenas de la forma a
n
b
n

La notacin a
n
b
n
se utiliza para denotar cadenas que consisten de n as
consecutivas seguidas de n bs consecutivas.

Es decir denota al lenguaje:

L = {w| w es de la forma a
n
b
n
para n > 0 }

La gramtica es parecida a la de los palndromes. Debemos checar que la primera
sea una a y la ltima una b.

<palabraLegal> := cadena vaca | a<palabraLegal>b

El algoritmo para reconocer cadenas de esta forma, podra ser:

esttica bool reconocer (Cad w, int limIzq, int limDer)
comienza
si limIzq > limDer entonces
regresa verdadero
otro
si w[limIzq] = a & w[limDer] = b entonces
regresa reconocer (w, limIzq+1, limDer-1)
otro
regresa falso
termina

4. Palindromes

Un palindrome es una cadena que se lee (escribe, en este caso) igual de izquierda
a derecha que de derecha a izquierda. Escribir una funcin que determine cuando
una cadena es o no un palindrome.

esttica bool palindrome (Cad c, int limIzq)
comienza
si limIzq > c.longitud entonces
regresa verdadero
otro
si c [limIzq] = c [limDer] entonces
regresa palindrome (c, limIzq+1)
otro
regresa falso
termina

44

5. Bsqueda binaria

esttica bool busbin (objeto [ ] A, int limIzq, int limDer, objeto valor)
comienza
regresa A [limDer].igual (valor)
otro
comienza
si A [m].igual (valor) entonces
regresa verdadero
otro
si valor.mayor(A [m]) entonces
regresa BusBin (A,m+1,limDer, valor)
otro
regresa BusBin (A,limIzq,m-1, valor)
termina
termina

6. MergeSort

Suponga dos arreglos ordenados A[1..n] y B[1..m] que se desean juntar en un solo
arreglo ordenado C[1..n+m]

esttica void Merge (Objeto [ ] A, Objeto [ ] B, Objeto [ ] C)
comienza
i 1; j 1; k 1;
mientras i < n & j < m
comienza
si A[i] < B[j] entonces
C[k] A[i]; i++
otro
C[k] B[j]; j++
k++
termina
Copia (C,k,A,i)
Copia (C,k,B,j)
termina

45
void MergeSort (Objeto [] A, int limIzq, int limDer)
comienza
si limIzq < limDer entonces
comienza
i (limIzq+limDer) div 2
MergeSort (A, limIzq, i)
MergeSort (A, i+1, limDer)
Merge (A,A,A)
termina
termina

7. Fractal cuadrado

Dibujar una figura complicada con absoluto realismo empleando una computadora
puede resultar en un trabajo bastante complicado para cualquier programador o
artista. En 1975, un matemtico francs llamado Bernoit Mandelbrot termin una
serie de investigaciones que duraron cerca de 20 aos. Mandelbrot llam al
resultado de sus investigaciones Geometra Fractal. Un fractal es un dibujo
formado por una geometra igual que la del dibujo pero de un tamao menor. Un
fractal se crea por clculos repetitivos similares que los que se necesitaron para
efectuar la parte inicial del dibujo. El fractal debe de seguir cierto orden para que
no se produzcan dibujos que al final resultaran en un amontonamiento de lneas.
Utilizando este mtodo se pueden llegar a producir dibujos de una gran calidad y
similitud con la realidad.

esttica void cuadrado (int x,int y,int r)
comienza
si r > 0 entonces
comienza
pintaCuadrado (x,y,r)
cuadrado (x-r,y+r, r div 2)
cuadrado (x+r,y+r, r div 2)
cuadrado (x-r,y-r, r div 2)
cuadrado (x+r,y-r, r div 2)
termina
termina

8. Dibujar recursivamente las marcas de una regla:

46
esttica void regla (int ini, int fin, int n)
comienza
si n > 0 entonces
comienza
m (ini+fin) div 2
marca (m,n)
regla (ini, m, n-1)
regla (m, fin, n-1)
termina
termina

regla (0,4,2)
marca (2,2)
regla (0,2,1)
marca (1,1)
regla (0,1,0)
regla (1,2,0)
regla (2,4,1)
marca (3,1)
regla (2,3,0)
regla (3,4,0)

10. Torres de Hanoi

esttica void hanoi (Torre A, Torre B, Torre C, int n)
// se desean mover n discos de la torre A a la B utilizando a C como auxiliar
comienza
si n = 1 entonces
A --> B //se mueve un disco de A a B
otro
comienza
hanoi (A,C,B,n-1)
A --> B
hanoi (C,A,B,n-1)
termina
termina

Ejercicios:

1. Desarrolle una funcin para calcular recursivamente el nmero de ocurrencias
del elemento elem en el vector A.
2. Desarrolle una funcin recursiva para saber si un carcter dado se encuentra
presente en una cadena de caracteres.
3. Escriba una funcin recursiva para indicar si una cadena st1 ocurre dentro de
una cadena st2.

47
4. Desarrolle una funcin recursiva para determinar si dos vectores son iguales.
5. Escriba el algortimo para la funcin de Ackermann, que est definida como:

A(0,n) = n+1 para n > 0
A(m,0) = A(m-1, 1) para m > 0
A(m,n) = A(m-1, A(m,n-1)) para m > 0 y n > 0
6. Suponiendo que solo existe una rutina escribeDigito para escribir en la pantalla
un dgito (0-9) pasado como parmetro, desarrolle un procedimiento recursivo que
imprima un entero de cualquier cantidad de dgitos.
7. Multiplicacin de nmeros naturales. El producto de a*b donde a y b son
enteros positivos, se puede definir como a sumando a s mismo un nmero de
veces igual a b.
a*b = a si b = 1
a*b = a*(b-1) + a si b > 1

8. Considere un arreglo de enteros. Escriba algoritmos recursivos para calcular:
(a) la suma de los elementos del arreglo
(b) el producto de los elementos del arreglo
(c) el promedio de los elementos del arreglo

9. Determine qu calcula la siguiente funcin recursiva y escriba una funcin
iterativa que realice lo mismo:

esttica int f (int n)
comienza
si n= 0
regresa 0
otro
regresa n + f (n-1)
termina

LIstas Pilas Colas Recursividad

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

LIstas Pilas Colas Recursividad

Încărcat de

Drepturi de autor:

Formate disponibile

Listas Pilas - Colas.

S-ar putea să vă placă și